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

package/src/util/navigation_from_path.ts

@@ -0,0 +1,107 @@
+import { EntityCollection, EntityCustomView } from "../types";
+import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
+import { resolveEntityView } from "./resolutions";
+
+export type NavigationViewInternal<M extends Record<string, any> = any> =
+    | NavigationViewEntityInternal<M>
+    | NavigationViewCollectionInternal<M>
+    | NavigationViewEntityCustomInternal<M>;
+
+export interface NavigationViewEntityInternal<M extends Record<string, any>> {
+    type: "entity";
+    entityId: string;
+    path: string;
+    parentCollection: EntityCollection<M>;
+}
+
+export interface NavigationViewCollectionInternal<M extends Record<string, any>> {
+    type: "collection";
+    path: string;
+    collection: EntityCollection<M>;
+}
+
+export interface NavigationViewEntityCustomInternal<M extends Record<string, any>> {
+    type: "custom_view";
+    path: string;
+    view: EntityCustomView<M>;
+}
+
+export function getNavigationEntriesFromPathInternal(props: {
+    path: string,
+    collections: EntityCollection[] | undefined,
+    currentFullPath?: string,
+    contextEntityViews?: EntityCustomView<any>[]
+}): NavigationViewInternal [] {
+
+    const {
+        path,
+        collections = [],
+        currentFullPath
+    } = props;
+
+    const subpaths = removeInitialAndTrailingSlashes(path).split("/");
+    const subpathCombinations = getCollectionPathsCombinations(subpaths);
+
+    const result: NavigationViewInternal[] = [];
+    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;
+
+            result.push({
+                type: "collection",
+                path: collectionPath,
+                collection
+            });
+            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({
+                    type: "entity",
+                    entityId,
+                    path: collectionPath,
+                    parentCollection: collection
+                });
+                if (nextSegments.length > 1) {
+                    const newPath = nextSegments.slice(1).join("/");
+                    if (!collection) {
+                        throw Error("collection not found resolving path: " + collection);
+                    }
+                    const entityViews = collection.entityViews;
+                    const customView = entityViews && entityViews
+                        .map((entry) => resolveEntityView(entry, props.contextEntityViews))
+                        .filter(Boolean)
+                        .find((entry) => entry!.key === newPath);
+                    if (customView) {
+                        const path = currentFullPath && currentFullPath.length > 0
+                            ? (currentFullPath + "/" + customView.key)
+                            : customView.key;
+                        result.push({
+                            type: "custom_view",
+                            path,
+                            view: customView
+                        });
+                    } else if (collection.subcollections) {
+                        result.push(...getNavigationEntriesFromPathInternal({
+                            path: newPath,
+                            collections: collection.subcollections,
+                            currentFullPath: fullPath,
+                            contextEntityViews: props.contextEntityViews
+                        }));
+                    }
+                }
+            }
+            break;
+        }
+
+    }
+    return result;
+}

package/src/util/navigation_utils.ts

@@ -0,0 +1,111 @@
+import { EntityCollection } from "../types";
+
+export function removeInitialAndTrailingSlashes(s: string): string {
+    return removeInitialSlash(removeTrailingSlash(s));
+}
+
+export function removeInitialSlash(s: string) {
+    if (s.startsWith("/"))
+        return s.slice(1);
+    else return s;
+}
+
+export function removeTrailingSlash(s: string) {
+    if (s.endsWith("/"))
+        return s.slice(0, -1);
+    else return s;
+}
+
+export function addInitialSlash(s: string) {
+    if (s.startsWith("/"))
+        return s;
+    else return `/${s}`;
+}
+
+export function getLastSegment(path: string) {
+    const cleanPath = removeInitialAndTrailingSlashes(path);
+    if (cleanPath.includes("/")) {
+        const segments = cleanPath.split("/");
+        return segments[segments.length - 1];
+    }
+    return cleanPath;
+}
+
+export function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string {
+
+    const cleanPath = removeInitialAndTrailingSlashes(path);
+    const subpaths = cleanPath.split("/");
+    if (subpaths.length % 2 === 0) {
+        throw Error(`resolveCollectionPathAliases: Collection paths must have an odd number of segments: ${path}`);
+    }
+
+    const aliasedCollection = allCollections.find((col) => col.id === subpaths[0]);
+    let resolvedAliased;
+    if (aliasedCollection) {
+        resolvedAliased = aliasedCollection.path;
+    }
+
+    if (subpaths.length > 1) {
+        const segmentCollection = getCollectionByPathOrId(resolvedAliased ?? subpaths[0], allCollections);
+        if (!segmentCollection?.subcollections) {
+            return cleanPath;
+        }
+        const restOfThePath = cleanPath.split("/").slice(2).join("/");
+        return (resolvedAliased ?? subpaths[0]) + "/" + subpaths[1] + "/" + resolveCollectionPathIds(restOfThePath, segmentCollection.subcollections);
+    } else {
+        return resolvedAliased ?? cleanPath;
+    }
+}
+
+/**
+ * Find the corresponding view at any depth for a given path.
+ * Note that path or segments of the paths can be collection aliases.
+ * @param pathOrAlias
+ * @param collections
+ */
+export function getCollectionByPathOrId(pathOrAlias: string, collections: EntityCollection[]): EntityCollection | undefined {
+
+    const subpaths = removeInitialAndTrailingSlashes(pathOrAlias).split("/");
+    if (subpaths.length % 2 === 0) {
+        throw Error(`getCollectionByPathOrAlias: Collection paths must have an odd number of segments: ${pathOrAlias}`);
+    }
+
+    const subpathCombinations = getCollectionPathsCombinations(subpaths);
+    let result: EntityCollection | undefined;
+    for (let i = 0; i < subpathCombinations.length; i++) {
+        const subpathCombination = subpathCombinations[i];
+        const navigationEntry = collections && collections
+            .sort((a, b) => (a.id ?? "").localeCompare(b.id ?? ""))
+            .find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
+
+        if (navigationEntry) {
+
+            if (subpathCombination === pathOrAlias) {
+                result = navigationEntry;
+            } else if (navigationEntry.subcollections) {
+                const newPath = pathOrAlias.replace(subpathCombination, "").split("/").slice(2).join("/");
+                if (newPath.length > 0)
+                    result = getCollectionByPathOrId(newPath, navigationEntry.subcollections);
+            }
+        }
+        if (result) break;
+    }
+    return result;
+}
+
+/**
+ * Get the subcollection combinations from a path:
+ * "sites/es/locales" => ["sites/es/locales", "sites"]
+ * @param subpaths
+ */
+export function getCollectionPathsCombinations(subpaths: string[]): string[] {
+    const entries = subpaths.length > 0 && subpaths.length % 2 === 0 ? subpaths.splice(0, subpaths.length - 1) : subpaths;
+
+    const length = entries.length;
+    const result: string[] = [];
+    for (let i = length; i > 0; i = i - 2) {
+        result.push(entries.slice(0, i).join("/"));
+    }
+    return result;
+
+}

package/src/util/objects.ts

@@ -0,0 +1,168 @@
+import hash from "object-hash";
+import { GeoPoint } from "../types";
+
+export const pick: <T>(obj: T, ...args: any[]) => T = (obj: any, ...args: any[]) => ({
+    ...args.reduce((res, key) => ({
+        ...res,
+        [key]: obj[key]
+    }), {})
+});
+
+export function isObject(item: any) {
+    return item && typeof item === "object" && !Array.isArray(item);
+}
+
+export function mergeDeep<T extends object>(target: T, source: any): T {
+    const targetIsObject = isObject(target);
+    const output: T = targetIsObject ? { ...target } : target;
+    if (targetIsObject && isObject(source)) {
+        Object.keys(source).forEach(key => {
+            if (isObject(source[key])) {
+                if (!(key in target))
+                    Object.assign(output, { [key]: source[key] });
+                else
+                    (output as any)[key] = mergeDeep((target as any)[key], source[key]);
+            } else {
+                Object.assign(output, { [key]: source[key] });
+            }
+        });
+    }
+    return output;
+}
+
+// export function getValueInPath(o: object | undefined, path: string): any {
+//     if (!o) return undefined;
+//     if (typeof o === "object") {
+//         if (path in o) {
+//             return (o as any)[path];
+//         }
+//         if (path.includes(".")) {
+//             const pathSegments = path.split(".");
+//             return getValueInPath((o as any)[pathSegments[0]], pathSegments.slice(1).join("."))
+//         }
+//     }
+//     return undefined;
+// }
+
+export function getValueInPath(o: object | undefined, path: string): any {
+    if (!o) return undefined;
+    if (typeof o === "object") {
+        if (path in o) {
+            return (o as any)[path];
+        }
+        if (path.includes(".") || path.includes("[")) {
+            let pathSegments = path.split(/[.[]/);
+            if (path.includes("[")) {
+                pathSegments = pathSegments.map(segment => segment.replace("]", ""));
+            }
+            const firstSegment = pathSegments[0];
+            const isArrayAndIndexExists = Array.isArray((o as any)[firstSegment]) && !isNaN(parseInt(pathSegments[1]));
+            const nextObject = isArrayAndIndexExists
+                ? (o as any)[firstSegment][parseInt(pathSegments[1])]
+                : (o as any)[firstSegment];
+
+            const nextPath = pathSegments.slice(isArrayAndIndexExists ? 2 : 1).join(".");
+            if (nextPath === "")
+                return nextObject;
+            return getValueInPath(nextObject, nextPath)
+        }
+    }
+    return undefined;
+}
+
+export function removeInPath(o: object, path: string): object | undefined {
+    let currentObject = { ...o };
+    const parts = path.split(".");
+    const last = parts.pop();
+    for (const part of parts) {
+        currentObject = (currentObject as any)[part]
+    }
+    if (last)
+        delete (currentObject as any)[last];
+    return currentObject;
+}
+
+export function removeFunctions(o: object | undefined): any {
+    if (o === undefined) return undefined;
+    if (o === null) return null;
+    if (typeof o === "object") {
+        return Object.entries(o)
+            .filter(([_, value]) => typeof value !== "function")
+            .map(([key, value]) => {
+                if (Array.isArray(value)) {
+                    return { [key]: value.map(v => removeFunctions(v)) };
+                } else if (typeof value === "object") {
+                    return { [key]: removeFunctions(value) };
+                } else return { [key]: value };
+            })
+            .reduce((a, b) => ({ ...a, ...b }), {});
+    }
+    return o;
+}
+
+export function getHashValue<T>(v: T) {
+    if (!v) return null;
+    if (typeof v === "object") {
+        if ("id" in v)
+            return (v as any).id;
+        else if (v instanceof Date)
+            return v.toLocaleString();
+        else if (v instanceof GeoPoint)
+            return hash(v as Record<string, unknown>);
+    }
+    return hash(v, { ignoreUnknown: true });
+}
+
+export function removeUndefined(value: any, removeEmptyStrings?: boolean): any {
+    if (typeof value === "function") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v: any) => removeUndefined(v, removeEmptyStrings));
+    }
+    if (typeof value === "object") {
+        const res: object = {};
+        if (value === null)
+            return value;
+        Object.keys(value).forEach((key) => {
+            if (!isEmptyObject(value)) {
+                const childRes = removeUndefined(value[key], removeEmptyStrings);
+                const isString = typeof childRes === "string";
+                const shouldKeepIfString = !removeEmptyStrings || (removeEmptyStrings && !isString) || (removeEmptyStrings && isString && childRes !== "");
+                if (childRes !== undefined && !isEmptyObject(childRes) && shouldKeepIfString)
+                    (res as any)[key] = childRes;
+            }
+        });
+        return res;
+    }
+    return value;
+}
+
+export function isEmptyObject(obj: object) {
+    return obj &&
+        Object.getPrototypeOf(obj) === Object.prototype &&
+        Object.keys(obj).length === 0
+}
+
+export function removePropsIfExisting(source: any, comparison: any) {
+    const isObject = (val: any) => typeof val === "object" && val !== null;
+    const isArray = (val: any) => Array.isArray(val);
+
+    if (!isObject(source) || !isObject(comparison)) {
+        return source;
+    }
+
+    const res = isArray(source) ? [...source] : { ...source };
+
+    Object.keys(comparison).forEach(key => {
+        if (key in res) {
+            if (isObject(res[key]) && isObject(comparison[key])) {
+                res[key] = removePropsIfExisting(res[key], comparison[key]);
+            } else if (res[key] === comparison[key]) {
+                isArray(res) ? res.splice(key, 1) : delete res[key];
+            }
+        }
+    });
+
+    return res;
+}

package/src/util/os.ts

@@ -0,0 +1,13 @@
+export function getOS() {
+    let OS = "Unknown";
+    if (navigator.userAgent.indexOf("Win") !== -1) OS = "Windows";
+    if (navigator.userAgent.indexOf("Mac") !== -1) OS = "MacOS";
+    if (navigator.userAgent.indexOf("X11") !== -1) OS = "UNIX";
+    if (navigator.userAgent.indexOf("Linux") !== -1) OS = "Linux";
+    return OS;
+}
+
+export function getAltSymbol() {
+    if (getOS() === "MacOS") return "⌥";
+    return "Alt";
+}

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 }), {});
+// }