@firecms/core 3.0.0-alpha.7 → 3.0.0-alpha.70

package/src/util/collections.ts

@@ -0,0 +1,50 @@
+import {
+    DefaultSelectedViewBuilder,
+    DefaultSelectedViewParams,
+    PropertiesOrBuilders,
+    PropertyOrBuilder
+} from "../types";
+import { isPropertyBuilder } from "./entities";
+
+export function sortProperties<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, propertiesOrder?: (keyof M)[]): PropertiesOrBuilders<M> {
+    try {
+        const propertiesKeys = Object.keys(properties);
+        const allPropertiesOrder = propertiesOrder ?? propertiesKeys;
+        return allPropertiesOrder
+            .map((key) => {
+                if (properties[key as keyof M]) {
+                    const property = properties[key] as PropertyOrBuilder;
+                    if (!isPropertyBuilder(property) && property?.dataType === "map" && property.properties) {
+                        return ({
+                            [key]: {
+                                ...property,
+                                properties: sortProperties(property.properties, property.propertiesOrder)
+                            }
+                        });
+                    } else {
+                        return ({ [key]: property });
+                    }
+                } else {
+                    return undefined;
+                }
+            })
+            .filter((a) => a !== undefined)
+            .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as PropertiesOrBuilders<M>;
+    } catch (e) {
+        console.error("Error sorting properties", e);
+        return properties;
+    }
+}
+
+export function resolveDefaultSelectedView(
+    defaultSelectedView: string | DefaultSelectedViewBuilder | undefined,
+    params: DefaultSelectedViewParams
+) {
+    if (!defaultSelectedView) {
+        return undefined;
+    } else if (typeof defaultSelectedView === "string") {
+        return defaultSelectedView;
+    } else {
+        return defaultSelectedView(params);
+    }
+}

package/src/util/common.tsx

@@ -0,0 +1,2 @@
+export const DEFAULT_ONE_OF_TYPE = "type"
+export const DEFAULT_ONE_OF_VALUE = "value"

package/src/util/dates.ts

@@ -0,0 +1 @@
+export const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";

package/src/util/entities.ts

@@ -0,0 +1,196 @@
+import {
+    CMSType,
+    DataType,
+    Entity,
+    EntityReference,
+    EntityStatus,
+    EntityValues,
+    Properties,
+    PropertiesOrBuilders,
+    Property,
+    PropertyBuilder,
+    PropertyOrBuilder,
+    ResolvedProperties,
+    ResolvedProperty
+} from "../types";
+import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
+
+export function isReadOnly(property: Property | ResolvedProperty): boolean {
+    if (property.readOnly)
+        return true;
+    if (property.dataType === "date") {
+        if (property.autoValue)
+            return true;
+    }
+    if (property.dataType === "reference") {
+        return !property.path;
+    }
+    return false;
+}
+
+export function isHidden(property: Property | ResolvedProperty): boolean {
+    return typeof property.disabled === "object" && Boolean(property.disabled.hidden);
+}
+
+export function isPropertyBuilder<T extends CMSType, M extends Record<string, any>>(propertyOrBuilder?: PropertyOrBuilder<T, M> | Property<T> | ResolvedProperty<T>): propertyOrBuilder is PropertyBuilder<T, M> {
+    return typeof propertyOrBuilder === "function";
+}
+
+export function getDefaultValuesFor<M extends Record<string, any>>(properties: PropertiesOrBuilders<M> | ResolvedProperties<M>): Partial<EntityValues<M>> {
+    if (!properties) return {};
+    return Object.entries(properties)
+        .map(([key, property]) => {
+            const value = getDefaultValueFor(property as PropertyOrBuilder);
+            return value === undefined ? {} : { [key]: value };
+        })
+        .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
+}
+
+export function getDefaultValueFor(property: PropertyOrBuilder) {
+    if (isPropertyBuilder(property)) return undefined;
+    if (property.dataType === "map" && property.properties) {
+        const defaultValuesFor = getDefaultValuesFor(property.properties as Properties);
+        if (Object.keys(defaultValuesFor).length === 0) return undefined;
+        return defaultValuesFor;
+    } else if (property.defaultValue) {
+        return property.defaultValue;
+    } else {
+        return getDefaultValueForDataType(property.dataType);
+    }
+}
+
+export function getDefaultValueForDataType(dataType: DataType) {
+    if (dataType === "string") {
+        return null;
+    } else if (dataType === "number") {
+        return null;
+    } else if (dataType === "boolean") {
+        return false;
+    } else if (dataType === "date") {
+        return null;
+    } else if (dataType === "array") {
+        return [];
+    } else if (dataType === "map") {
+        return {};
+    } else {
+        return null;
+    }
+}
+
+/**
+ * Update the automatic values in an entity before save
+ * @group Datasource
+ */
+export function updateDateAutoValues<M extends Record<string, any>>({
+                                                                        inputValues,
+                                                                        properties,
+                                                                        status,
+                                                                        timestampNowValue,
+                                                                        setDateToMidnight
+                                                                    }:
+                                                                        {
+                                                                            inputValues: Partial<EntityValues<M>>,
+                                                                            properties: ResolvedProperties<M>,
+                                                                            status: EntityStatus,
+                                                                            timestampNowValue: any,
+                                                                            setDateToMidnight: (input?: any) => any | undefined
+                                                                        }): EntityValues<M> {
+    return traverseValuesProperties(
+        inputValues,
+        properties,
+        (inputValue, property) => {
+            if (property.dataType === "date") {
+                let resultDate;
+                if (status === "existing" && property.autoValue === "on_update") {
+                    resultDate = timestampNowValue;
+                } else if ((status === "new" || status === "copy") &&
+                    (property.autoValue === "on_update" || property.autoValue === "on_create")) {
+                    resultDate = timestampNowValue;
+                } else {
+                    resultDate = inputValue;
+                }
+                if (property.mode === "date")
+                    resultDate = setDateToMidnight(resultDate);
+                return resultDate;
+            } else {
+                return inputValue;
+            }
+        }
+    ) ?? {} as M;
+}
+
+/**
+ * Add missing required fields, expected in the collection, to the values of an entity
+ * @param values
+ * @param properties
+ * @group Datasource
+ */
+export function sanitizeData<M extends Record<string, any>>
+(
+    values: EntityValues<M>,
+    properties: ResolvedProperties<M>
+) {
+    const result: any = values;
+    Object.entries(properties)
+        .forEach(([key, property]) => {
+            if (values && values[key] !== undefined) result[key] = values[key];
+            else if ((property as Property).validation?.required) result[key] = null;
+        });
+    return result;
+}
+
+export function getReferenceFrom<M extends Record<string, any>>(entity: Entity<M>): EntityReference<M> {
+    return new EntityReference(entity.id, entity.path);
+}
+
+export function traverseValuesProperties<M extends Record<string, any>>(
+    inputValues: Partial<EntityValues<M>>,
+    properties: ResolvedProperties<M>,
+    operation: (value: any, property: Property) => any
+): EntityValues<M> | undefined {
+    const updatedValues = Object.entries(properties)
+        .map(([key, property]) => {
+            const inputValue = inputValues && (inputValues)[key];
+            const updatedValue = traverseValueProperty(inputValue, property as Property, operation);
+            if (updatedValue === undefined) return undefined;
+            return ({ [key]: updatedValue });
+        })
+        .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
+    const result = { ...inputValues, ...updatedValues };
+    if (Object.keys(result).length === 0) return undefined;
+    return result;
+}
+
+export function traverseValueProperty(inputValue: any,
+                                      property: Property,
+                                      operation: (value: any, property: Property) => any): any {
+
+    let value;
+    if (property.dataType === "map" && property.properties) {
+        value = traverseValuesProperties(inputValue, property.properties as ResolvedProperties, operation);
+    } else if (property.dataType === "array") {
+        if (property.of && Array.isArray(inputValue)) {
+            value = inputValue.map((e) => traverseValueProperty(e, property.of as Property, operation));
+        } else if (property.oneOf && Array.isArray(inputValue)) {
+            const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+            const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_VALUE;
+            value = inputValue.map((e) => {
+                if (e === null) return null;
+                if (typeof e !== "object") return e;
+                const type = e[typeField];
+                const childProperty = property.oneOf?.properties[type];
+                if (!type || !childProperty) return e;
+                return {
+                    [typeField]: type,
+                    [valueField]: traverseValueProperty(e[valueField], childProperty, operation)
+                };
+            });
+        } else {
+            value = inputValue;
+        }
+    } else {
+        value = operation(inputValue, property);
+    }
+
+    return value;
+}

package/src/util/enums.ts

@@ -0,0 +1,57 @@
+import { EnumValueConfig, EnumValues } from "../types";
+import { CHIP_COLORS, ChipColorScheme } from "@firecms/ui";
+import { getColorSchemeForSeed } from "./chip_utils";
+
+export function enumToObjectEntries(enumValues: EnumValues): EnumValueConfig[] {
+    if (Array.isArray(enumValues)) {
+        return enumValues;
+    } else {
+        return Object.entries(enumValues).map(([id, value]) => {
+            if (typeof value === "string") {
+                return {
+                    id,
+                    label: value
+                }
+            } else {
+                return {
+                    ...value,
+                    id
+                }
+            }
+        });
+    }
+}
+
+export function getLabelOrConfigFrom(enumValues: EnumValueConfig[], key?: string | number): EnumValueConfig | undefined {
+    if (!key) return undefined;
+    return enumValues.find((entry) => String(entry.id) === String(key));
+}
+
+export function getColorScheme(enumValues: EnumValueConfig[], key: string | number): ChipColorScheme | undefined {
+    const labelOrConfig = getLabelOrConfigFrom(enumValues, key);
+    if (!labelOrConfig?.color)
+        return getColorSchemeForSeed(key.toString());
+    if (typeof labelOrConfig === "object" && "color" in labelOrConfig) {
+        if (typeof labelOrConfig.color === "string")
+            return CHIP_COLORS[labelOrConfig.color];
+        if (typeof labelOrConfig.color === "object")
+            return labelOrConfig.color;
+    }
+    return undefined;
+}
+
+export function isEnumValueDisabled(labelOrConfig?: string | EnumValueConfig) {
+    return typeof labelOrConfig === "object" && (labelOrConfig as EnumValueConfig).disabled;
+}
+
+export function buildEnumLabel(
+    labelOrConfig?: string | EnumValueConfig
+): string | undefined {
+    if (labelOrConfig === undefined)
+        return undefined;
+    if (typeof labelOrConfig === "object") {
+        return labelOrConfig.label;
+    } else {
+        return labelOrConfig;
+    }
+}

package/src/util/flatten_object.ts

@@ -0,0 +1,45 @@
+export function flattenObject(obj: any, parentKey = "") {
+    if (!obj) return obj;
+    return Object.keys(obj).reduce((flatObj, key) => {
+        const newKey = parentKey ? `${parentKey}.${key}` : key;
+
+        if (typeof obj[key] === "object" && obj[key] !== null) {
+            if (Array.isArray(obj[key])) {
+                obj[key].forEach((item: any, index: number) => {
+                    Object.assign(flatObj, flattenObject(item, `${newKey}[${index}]`));
+                });
+            } else {
+                Object.assign(flatObj, flattenObject(obj[key], newKey));
+            }
+        } else {
+            flatObj[newKey] = obj[key];
+        }
+
+        return flatObj;
+    }, {} as { [key: string]: any });
+}
+
+
+// map from nested property key like "a.b.c" to the maximum array count found in a list of objects for that array
+export type ArrayValuesCount = Record<string, number>;
+
+export function getArrayValuesCount(array: any[]): ArrayValuesCount {
+    return array.reduce((acc: ArrayValuesCount, obj: any) => {
+        Object.entries(obj).forEach(([key, value]) => {
+            // proceed only if value is an array
+            if (Array.isArray(value)) {
+                acc[key] = Math.max(acc[key] || 0, value.length);
+            }
+
+            // handle nested object
+            if (typeof value === "object" && value !== null) {
+                const nested = getArrayValuesCount([value]);
+                Object.entries(nested).forEach(([nestedKey, nestedCount]) => {
+                    const compoundKey = `${key}.${nestedKey}`;
+                    acc[compoundKey] = Math.max(acc[compoundKey] || 0, nestedCount);
+                });
+            }
+        });
+        return acc;
+    }, {});
+}

package/src/util/hash.ts

@@ -0,0 +1,11 @@
+export function hashString(str: string): number {
+    let hash = 0;
+    let i;
+    let chr;
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return Math.abs(hash);
+}

package/src/util/icons.tsx

@@ -0,0 +1,45 @@
+import React from "react";
+import { CMSView, EntityCollection } from "../types";
+import { hashString } from "./hash";
+import { coolIconKeys, Icon, iconKeys } from "@firecms/ui";
+import { slugify } from "./strings";
+
+export function getIcon(iconKey?: string, className?:string): React.ReactElement | undefined {
+    if (!iconKey) return undefined;
+    iconKey = slugify(iconKey);
+    if (!(iconKey in iconKeysMap)) {
+        return undefined;
+    }
+    return iconKey in iconKeysMap ? <Icon iconKey={iconKey} size={"medium"} className={className}/> : undefined;
+}
+
+export function getIconForView(collectionOrView: EntityCollection | CMSView, className?:string): React.ReactElement {
+
+    const icon = getIcon(collectionOrView.icon, className);
+    if (collectionOrView?.icon && icon)
+        return icon;
+
+    let slugName = slugify(("singularName" in collectionOrView ? collectionOrView.singularName : undefined) ?? collectionOrView.name);
+
+    let key: string | undefined;
+    if (slugName in iconKeysMap)
+        key = slugName;
+
+    if (!key) {
+        slugName = slugify(collectionOrView.path);
+        if (slugName in iconKeysMap)
+            key = slugName;
+    }
+
+    const iconsCount = coolIconKeys.length;
+
+    if (!key)
+        key = coolIconKeys[hashString(collectionOrView.path) % iconsCount];
+
+    return <Icon iconKey={key} size={"medium"} className={className}/>;
+}
+
+const iconKeysMap: Record<string, string> = iconKeys.reduce((acc: Record<string, string>, key) => {
+    acc[key] = key;
+    return acc;
+}, {});

package/src/util/index.ts

@@ -0,0 +1,20 @@
+export * from "./collections";
+export * from "./entities";
+export * from "./strings";
+export * from "./dates";
+export * from "./enums";
+export * from "./objects";
+export * from "./paths";
+export * from "./regexp";
+export * from "./navigation_utils";
+export * from "./useDebounce";
+export * from "./property_utils";
+export * from "./resolutions";
+export * from "./permissions";
+export * from "./icons";
+export * from "./plurals";
+export * from "./references";
+export * from "./flatten_object";
+export * from "./make_properties_editable";
+export * from "./join_collections";
+export * from "./builders";

package/src/util/join_collections.ts

@@ -0,0 +1,172 @@
+import {
+    EntityCollection,
+    MapProperty,
+    ModifyCollectionProps,
+    PropertiesOrBuilders,
+    Property,
+    PropertyOrBuilder
+} from "../types";
+import { mergeDeep } from "./objects";
+import { sortProperties } from "./collections";
+import { isPropertyBuilder } from "./entities";
+
+function applyModifyFunction(modifyCollection: ((props: ModifyCollectionProps) => (EntityCollection | void)) | undefined,
+                             collection: EntityCollection,
+                             parentPaths: string[]) {
+    if (modifyCollection) {
+        const modified = modifyCollection({
+            collection,
+            parentPaths
+        });
+        const resCollection = modified ?? collection;
+        if (resCollection.subcollections) {
+            resCollection.subcollections = resCollection.subcollections.map((subcollection) => {
+                return applyModifyFunction(modifyCollection, subcollection, [...parentPaths, collection.path]);
+            });
+        }
+        return resCollection;
+    } else {
+        return collection;
+    }
+}
+
+/**
+ *
+ */
+export function joinCollectionLists(targetCollections: EntityCollection[],
+                                    sourceCollections: EntityCollection[] | undefined,
+                                    parentPaths: string[] = [],
+                                    modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void): EntityCollection[] {
+
+    // merge collections that are in both lists
+    const updatedCollections = (sourceCollections ?? [])
+        .map((sourceCol) => {
+            const targetCol = targetCollections?.find((collection) => {
+                return collection.id === sourceCol.id;
+                // return collection.path === codedCollection.path || collection.id && codedCollection.id;
+            });
+            if (!targetCol) {
+                return applyModifyFunction(modifyCollection, sourceCol, parentPaths);
+            } else {
+                return mergeCollection(targetCol, sourceCol, parentPaths, modifyCollection);
+            }
+        });
+
+    const sourceCollectionIds = updatedCollections.map(c => c.id);
+    // fetched collections that are not in the source collections
+    const resultStoredCollections = targetCollections
+        .filter((col) => {
+            return !sourceCollectionIds.includes(col.id);
+        })
+        .map((col) => {
+            if (modifyCollection) {
+                return applyModifyFunction(modifyCollection, col, parentPaths);
+            } else {
+                return col;
+            }
+        });
+
+    return [...updatedCollections, ...resultStoredCollections];
+}
+
+/**
+ *
+ */
+export function mergeCollection(target: EntityCollection,
+                                source: EntityCollection,
+                                parentPaths: string[] = [],
+                                modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void
+): EntityCollection {
+
+    const subcollectionsMerged = joinCollectionLists(
+        target?.subcollections ?? [],
+        source?.subcollections ?? [],
+        [...parentPaths, target.path],
+        modifyCollection
+    );
+
+    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([...sourcePropertiesOrder, ...targetPropertiesOrder])];
+    const mergedEntityViews = [...new Set([...(target.entityViews ?? []), ...(source.entityViews ?? [])])];
+
+    let resultCollection: EntityCollection = {
+        ...mergedCollection,
+        subcollections: subcollectionsMerged,
+        properties: sortProperties(propertiesMerged, mergedPropertiesOrder),
+        propertiesOrder: mergedPropertiesOrder,
+        entityViews: mergedEntityViews
+    };
+    if (modifyCollection) {
+        const modifiedCollection = modifyCollection({
+            collection: resultCollection,
+            parentPaths
+        });
+        if (modifiedCollection)
+            resultCollection = modifiedCollection;
+    }
+    return resultCollection
+}
+
+function mergePropertyOrBuilder(target: PropertyOrBuilder, source: PropertyOrBuilder): PropertyOrBuilder {
+    if (isPropertyBuilder(source)) {
+        return source;
+    } else if (isPropertyBuilder(target)) {
+        return target;
+    } 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) {
+        const propertiesOrder = collection.propertiesOrder;
+        if (collection.additionalFields) {
+            collection.additionalFields.forEach((field) => {
+                if (!propertiesOrder.includes(field.key)) {
+                    propertiesOrder.push(field.key);
+                }
+            });
+        }
+        return propertiesOrder;
+    }
+    return [
+        ...Object.keys(collection.properties),
+        ...(collection.additionalFields ?? [])?.map(f => f.key)
+    ];
+}

package/src/util/make_properties_editable.ts

@@ -0,0 +1,29 @@
+import { Properties, PropertiesOrBuilders } from "../types";
+import { isPropertyBuilder } from "./entities";
+
+export function makePropertiesEditable(properties: Properties) {
+    Object.keys(properties).forEach((key) => {
+        const property = properties[key];
+        property.editable = true;
+        if (property.dataType === "map" && property.properties) {
+            makePropertiesEditable(property.properties as Properties);
+        }
+    });
+    return properties;
+}
+
+export function makePropertiesNonEditable(properties: PropertiesOrBuilders): PropertiesOrBuilders {
+    return Object.entries(properties).reduce((acc, [key, property]) => {
+        if (!isPropertyBuilder(property) && property.dataType === "map" && property.properties) {
+            const updated = { ...property, properties: makePropertiesNonEditable(property.properties as PropertiesOrBuilders) };
+            acc[key] = updated;
+        }
+        if (isPropertyBuilder(property)) {
+            acc[key] = property;
+        } else {
+            acc[key] = { ...property, editable: false };
+        }
+        return acc;
+    }, {} as PropertiesOrBuilders);
+
+}