@firecms/core 3.0.0-alpha.8 → 3.0.0-alpha.81

package/src/util/parent_references_from_path.ts

@@ -0,0 +1,56 @@
+import { EntityCollection, EntityReference } from "../types";
+import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
+
+export function getParentReferencesFromPath(props: {
+    path: string,
+    collections: EntityCollection[] | undefined,
+    currentFullPath?: string,
+}): EntityReference [] {
+
+    const {
+        path,
+        collections = [],
+        currentFullPath,
+    } = props;
+
+    const subpaths = removeInitialAndTrailingSlashes(path).split("/");
+    const subpathCombinations = getCollectionPathsCombinations(subpaths);
+
+    const result: EntityReference[] = [];
+    for (let i = 0; i < subpathCombinations.length; i++) {
+        const subpathCombination = subpathCombinations[i];
+
+        const collection: EntityCollection<any> | undefined = collections && collections.find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
+
+        if (collection) {
+            const pathOrAlias = collection.id ?? collection.path;
+            const collectionPath = currentFullPath && currentFullPath.length > 0
+                ? (currentFullPath + "/" + pathOrAlias)
+                : pathOrAlias;
+
+            const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
+            const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];
+            if (nextSegments.length > 0) {
+                const entityId = nextSegments[0];
+                const fullPath = collectionPath + "/" + entityId;
+                result.push(new EntityReference(entityId, collectionPath));
+                if (nextSegments.length > 1) {
+                    const newPath = nextSegments.slice(1).join("/");
+                    if (!collection) {
+                        throw Error("collection not found resolving path: " + collection);
+                    }
+                    if (collection.subcollections) {
+                        result.push(...getParentReferencesFromPath({
+                            path: newPath,
+                            collections: collection.subcollections,
+                            currentFullPath: fullPath
+                        }));
+                    }
+                }
+            }
+            break;
+        }
+
+    }
+    return result;
+}

package/src/util/paths.ts

@@ -0,0 +1,27 @@
+export const COLLECTION_PATH_SEPARATOR = "::";
+
+/**
+ * Remove the entity ids from a given path
+ * `products/B44RG6APH/locales` => `products::locales`
+ * @param path
+ */
+export function stripCollectionPath(path: string): string {
+    return segmentsToStrippedPath(fullPathToCollectionSegments(path));
+}
+
+export function segmentsToStrippedPath(paths: string[]) {
+    if (paths.length === 1)
+        return paths[0];
+    return paths.reduce((a, b) => `${a}${COLLECTION_PATH_SEPARATOR}${b}`);
+}
+
+/**
+ * Extract the collection path routes
+ * `products/B44RG6APH/locales` => [`products`, `locales`]
+ * @param path
+ */
+export function fullPathToCollectionSegments(path: string): string[] {
+    return path
+        .split("/")
+        .filter((e, i) => i % 2 === 0);
+}

package/src/util/permissions.ts

@@ -0,0 +1,80 @@
+import { AuthController, Entity, EntityCollection, Permissions, User } from "../types";
+
+const DEFAULT_PERMISSIONS = {
+    read: true,
+    edit: true,
+    create: true,
+    delete: true
+};
+
+export function resolvePermissions<M extends Record<string, any>, UserType extends User>
+(collection: EntityCollection<M>,
+ authController: AuthController<UserType>,
+ pathSegments: string[],
+ entity: Entity<M> | null): Permissions {
+
+    const permission = collection.permissions;
+    if (permission === undefined) {
+        return DEFAULT_PERMISSIONS;
+    } else if (typeof permission === "object") {
+        return permission as Permissions;
+    } else if (typeof permission === "function") {
+        return permission({
+            entity,
+            user: authController.user,
+            authController,
+            collection,
+            pathSegments
+        });
+    }
+    console.error("Permissions:", permission);
+    throw Error("New type of permission added and not mapped");
+}
+
+export function canEditEntity<M extends Record<string, any>, UserType extends User>
+(
+    collection: EntityCollection<M>,
+    authController: AuthController<UserType>,
+    paths: string[],
+    entity: Entity<M> | null): boolean {
+    return resolvePermissions(collection, authController, paths, entity).edit ?? DEFAULT_PERMISSIONS.edit;
+}
+
+export function canCreateEntity<M extends Record<string, any>, UserType extends User>
+(
+    collection: EntityCollection<M>,
+    authController: AuthController<UserType>,
+    paths: string[],
+    entity: Entity<M> | null): boolean {
+    return resolvePermissions(collection, authController, paths, entity).create ?? DEFAULT_PERMISSIONS.create;
+}
+
+export function canDeleteEntity<M extends Record<string, any>, UserType extends User>
+(
+    collection: EntityCollection<M>,
+    authController: AuthController<UserType>,
+    paths: string[],
+    entity: Entity<M> | null): boolean {
+    return resolvePermissions(collection, authController, paths, entity).delete ?? DEFAULT_PERMISSIONS.delete;
+}
+
+// export function resolveCollectionsPermissions(roles: Role[]): Record<string, Permissions> {
+//     const collectionIds = Array.from(new Set(roles.flatMap(role => Object.keys(role.collections))));
+//     return collectionIds
+//         .map((colId) => {
+//             const rolesWithCollection = roles.filter((role) => colId in Object.keys(role.collections));
+//             return {
+//                 [colId]: rolesWithCollection
+//                     .map(role => role.collections[colId])
+//                     .reduce((permA, permB) => {
+//                         return {
+//                             read: permA.read ?? permB.read ?? false,
+//                             create: permA.create ?? permB.create ?? false,
+//                             edit: permA.edit ?? permB.edit ?? false,
+//                             delete: permA.delete ?? permB.delete ?? false
+//                         };
+//                     })
+//             };
+//         })
+//         .reduce((a, b) => ({ ...a, ...b }), {});
+// }

package/src/util/plurals.ts

@@ -0,0 +1,190 @@
+/**
+ * Returns the plural of an English word.
+ *
+ * @export
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export function plural(word: string, amount?: number): string {
+    if (amount !== undefined && amount === 1) {
+        return word
+    }
+    const plurals: { [key: string]: string } = {
+        "(quiz)$": "$1zes",
+        "^(ox)$": "$1en",
+        "([m|l])ouse$": "$1ice",
+        "(matr|vert|ind)ix|ex$": "$1ices",
+        "(x|ch|ss|sh)$": "$1es",
+        "([^aeiouy]|qu)y$": "$1ies",
+        "(hive)$": "$1s",
+        "(?:([^f])fe|([lr])f)$": "$1$2ves",
+        "(shea|lea|loa|thie)f$": "$1ves",
+        sis$: "ses",
+        "([ti])um$": "$1a",
+        "(tomat|potat|ech|her|vet)o$": "$1oes",
+        "(bu)s$": "$1ses",
+        "(alias)$": "$1es",
+        "(octop)us$": "$1i",
+        "(ax|test)is$": "$1es",
+        "(us)$": "$1es",
+        "([^s]+)$": "$1s"
+    }
+    const irregular: { [key: string]: string } = {
+        move: "moves",
+        foot: "feet",
+        goose: "geese",
+        sex: "sexes",
+        child: "children",
+        man: "men",
+        tooth: "teeth",
+        person: "people"
+    }
+    const uncountable: string[] = [
+        "sheep",
+        "fish",
+        "deer",
+        "moose",
+        "series",
+        "species",
+        "money",
+        "rice",
+        "information",
+        "equipment",
+        "bison",
+        "cod",
+        "offspring",
+        "pike",
+        "salmon",
+        "shrimp",
+        "swine",
+        "trout",
+        "aircraft",
+        "hovercraft",
+        "spacecraft",
+        "sugar",
+        "tuna",
+        "you",
+        "wood"
+    ]
+    // save some time in the case that singular and plural are the same
+    if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+        return word;
+    }
+    // check for irregular forms
+    for (const w in irregular) {
+        const pattern = new RegExp(`${w}$`, "i")
+        const replace = irregular[w]
+        if (pattern.test(word)) {
+            return word.replace(pattern, replace);
+        }
+    }
+    // check for matches using regular expressions
+    for (const reg in plurals) {
+        const pattern = new RegExp(reg, "i")
+        if (pattern.test(word)) {
+            return word.replace(pattern, plurals[reg])
+        }
+    }
+    return word;
+}
+
+/**
+ * Returns the singular of an English word.
+ *
+ * @export
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export function singular(word: string, amount?: number): string {
+    if (amount !== undefined && amount !== 1) {
+        return word;
+    }
+    const singulars: { [key: string]: string } = {
+        "(quiz)zes$": "$1",
+        "(matr)ices$": "$1ix",
+        "(vert|ind)ices$": "$1ex",
+        "^(ox)en$": "$1",
+        "(alias)es$": "$1",
+        "(octop|vir)i$": "$1us",
+        "(cris|ax|test)es$": "$1is",
+        "(shoe)s$": "$1",
+        "(o)es$": "$1",
+        "(bus)es$": "$1",
+        "([m|l])ice$": "$1ouse",
+        "(x|ch|ss|sh)es$": "$1",
+        "(m)ovies$": "$1ovie",
+        "(s)eries$": "$1eries",
+        "([^aeiouy]|qu)ies$": "$1y",
+        "([lr])ves$": "$1f",
+        "(tive)s$": "$1",
+        "(hive)s$": "$1",
+        "(li|wi|kni)ves$": "$1fe",
+        "(shea|loa|lea|thie)ves$": "$1f",
+        "(^analy)ses$": "$1sis",
+        "((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$": "$1$2sis",
+        "([ti])a$": "$1um",
+        "(n)ews$": "$1ews",
+        "(h|bl)ouses$": "$1ouse",
+        "(corpse)s$": "$1",
+        "(us)es$": "$1",
+        s$: ""
+    }
+    const irregular: { [key: string]: string } = {
+        move: "moves",
+        foot: "feet",
+        goose: "geese",
+        sex: "sexes",
+        child: "children",
+        man: "men",
+        tooth: "teeth",
+        person: "people"
+    }
+    const uncountable: string[] = [
+        "sheep",
+        "fish",
+        "deer",
+        "moose",
+        "series",
+        "species",
+        "money",
+        "rice",
+        "information",
+        "equipment",
+        "bison",
+        "cod",
+        "offspring",
+        "pike",
+        "salmon",
+        "shrimp",
+        "swine",
+        "trout",
+        "aircraft",
+        "hovercraft",
+        "spacecraft",
+        "sugar",
+        "tuna",
+        "you",
+        "wood"
+    ]
+    // save some time in the case that singular and plural are the same
+    if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+        return word;
+    }
+    // check for irregular forms
+    for (const w in irregular) {
+        const pattern = new RegExp(`${irregular[w]}$`, "i");
+        if (pattern.test(word)) {
+            return word.replace(pattern, w);
+        }
+    }
+    // check for matches using regular expressions
+    for (const reg in singulars) {
+        const pattern = new RegExp(reg, "i");
+        if (pattern.test(word)) {
+            return word.replace(pattern, singulars[reg]);
+        }
+    }
+    return word;
+}

package/src/util/property_utils.tsx

@@ -0,0 +1,130 @@
+import React from "react";
+
+import { EntityCollection, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedProperty } from "../types";
+import { isPropertyBuilder } from "./entities";
+import { resolveProperty } from "./resolutions";
+import { CircleIcon, FunctionsIcon } from "@firecms/ui";
+import { getFieldConfig } from "../core";
+
+export function isReferenceProperty(propertyOrBuilder: PropertyOrBuilder,
+                                    fields: Record<string, PropertyConfig>) {
+    const resolvedProperty = resolveProperty({
+        propertyKey: "ignore", // TODO
+        propertyOrBuilder,
+        fields
+    });
+    if (!resolvedProperty) return null;
+    if (resolvedProperty.dataType === "reference") {
+        return true;
+    }
+    if (resolvedProperty.dataType === "array") {
+        if (Array.isArray(resolvedProperty.of)) return false;
+        else return resolvedProperty.of?.dataType === "reference"
+    }
+    return false;
+}
+
+export function getIdIcon(size: "small" | "medium" | "large"): React.ReactNode {
+    return <CircleIcon size={size}/>;
+}
+
+export function getIconForWidget(widget: PropertyConfig | undefined,
+                                 size: "small" | "medium" | "large") {
+    const Icon = widget?.Icon ?? CircleIcon;
+    return <Icon size={size}/>;
+}
+
+export function getIconForProperty(
+    property: PropertyOrBuilder | ResolvedProperty,
+    size: "small" | "medium" | "large" = "small",
+    fields: Record<string, PropertyConfig> = {}
+): React.ReactNode {
+
+    if (isPropertyBuilder(property)) {
+        return <FunctionsIcon size={size}/>;
+    } else {
+        const widget = getFieldConfig(property, fields);
+        return getIconForWidget(widget, size);
+    }
+}
+
+export function getColorForProperty(property: PropertyOrBuilder, fields: Record<string, PropertyConfig>): string {
+    if (isPropertyBuilder(property)) {
+        return "#888";
+    } else {
+        const widget = getFieldConfig(property, fields);
+        return widget?.color ?? "#666";
+    }
+}
+
+/**
+ * Get a property in a property tree from a path like
+ * `address.street`
+ * @param properties
+ * @param path
+ */
+export function getPropertyInPath<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, path: string): PropertyOrBuilder<any, M> | undefined {
+    if (typeof properties === "object") {
+        if (path in properties) {
+            return properties[path];
+        }
+        if (path.includes(".")) {
+            const pathSegments = path.split(".");
+            const childProperty = properties[pathSegments[0]];
+            if (typeof childProperty === "object" && childProperty.dataType === "map" && childProperty.properties) {
+                return getPropertyInPath(childProperty.properties, pathSegments.slice(1).join("."))
+            }
+        }
+    }
+    return undefined;
+}
+
+export function getResolvedPropertyInPath(properties: Record<string, ResolvedProperty>, path: string): ResolvedProperty | undefined {
+    if (typeof properties === "object") {
+        if (path in properties) {
+            return properties[path];
+        }
+        if (path.includes(".")) {
+            const pathSegments = path.split(".");
+            const childProperty = properties[pathSegments[0]];
+            if (childProperty.dataType === "map" && childProperty.properties) {
+                return getResolvedPropertyInPath(childProperty.properties, pathSegments.slice(1).join("."))
+            }
+        }
+    }
+    return undefined;
+}
+
+// replace the dot notation with brackets
+// address.street => address[street]
+export function getBracketNotation(path: string): string {
+    return path.replace(/\.([^.]*)/g, "[$1]");
+}
+
+/**
+ * Get properties exclusively indexed by their order
+ * @param properties
+ * @param propertiesOrder
+ */
+export function getPropertiesWithPropertiesOrder<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, propertiesOrder?: Extract<keyof M, string>[]): PropertiesOrBuilders<M> {
+    if (!propertiesOrder) return properties;
+    const result: PropertiesOrBuilders<any> = {};
+    propertiesOrder.filter(Boolean).forEach(path => {
+        const property = getPropertyInPath(properties, path);
+        if (typeof property === "object" && property.dataType === "map" && property.properties) {
+            result[path] = {
+                ...property,
+                properties: getPropertiesWithPropertiesOrder(property.properties, property.propertiesOrder ?? [])
+            }
+        }
+        if (property) {
+            result[path] = property;
+        }
+    });
+    return result;
+}
+
+export function getDefaultPropertiesOrder(collection: EntityCollection<any>): string[] {
+    if (collection.propertiesOrder) return collection.propertiesOrder;
+    return [...Object.keys(collection.properties), ...(collection.additionalFields ?? []).map(field => field.key)];
+}

package/src/util/references.ts

@@ -0,0 +1,20 @@
+import { EntityCollection, PropertyConfig } from "../types";
+import { isReferenceProperty } from "./property_utils";
+import { isPropertyBuilder } from "./entities";
+
+export function getReferencePreviewKeys(targetCollection: EntityCollection<any>,
+                                        fields: Record<string, PropertyConfig>,
+                                        previewProperties?: string[],
+                                        limit = 3) {
+    const allProperties = Object.keys(targetCollection.properties);
+    let listProperties = previewProperties?.filter(p => allProperties.includes(p as string));
+    if (listProperties && listProperties.length > 0) {
+        return listProperties;
+    } else {
+        listProperties = allProperties;
+        return listProperties.filter(key => {
+            const propertyOrBuilder = targetCollection.properties[key];
+            return propertyOrBuilder && !isPropertyBuilder(propertyOrBuilder) && !isReferenceProperty(propertyOrBuilder, fields);
+        }).slice(0, limit);
+    }
+}

package/src/util/regexp.ts

@@ -0,0 +1,32 @@
+export function serializeRegExp(input: RegExp): string {
+    if (!input) return "";
+    // const fragments = input.toString().match(/\/(.*?)\/([a-z]*)?$/i);
+    // if (fragments) {
+    //     if (fragments[2])
+    //         return input.toString();
+    //     return fragments[1];
+    // }
+    return input.toString();
+}
+
+/**
+ * Get a RegExp out of a serialized string
+ * @param input
+ */
+export function hydrateRegExp(input?: string): RegExp | undefined {
+    if (!input) return undefined;
+    const fragments = input.match(/\/(.*?)\/([a-z]*)?$/i);
+    if (fragments) {
+        return new RegExp(fragments[1], fragments[2] || "");
+    } else {
+        return new RegExp(input, "");
+    }
+}
+
+export function isValidRegExp(input: string): boolean {
+    const fullRegexp = input.match(/\/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)\/((?:g(?:im?|mi?)?|i(?:gm?|mg?)?|m(?:gi?|ig?)?)?)/);
+    if (fullRegexp)
+        return true;
+    const simpleRegexp = input.match(/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)/);
+    return !!simpleRegexp;
+}