@firecms/core 3.0.0-canary.2 → 3.0.0-canary.200

package/src/types/side_dialogs_controller.tsx

@@ -1,3 +1,6 @@
+import React from "react";
+import { EntityFormProps } from "../form";
+
 /**
  * Controller to open the side dialog
  * @group Hooks and utilities
@@ -14,6 +17,12 @@ export interface SideDialogsController {
      */
     sidePanels: SideDialogPanelProps[];
 
+    /**
+     * Override the current side panels
+     * @param panels
+     */
+    setSidePanels: (panels: SideDialogPanelProps[]) => void;
+
     /**
      * Open one or multiple side panels
      * @param props
@@ -65,4 +74,10 @@ export interface SideDialogPanelProps {
      * Callback when the panel is closed
      */
     onClose?: () => void;
+
+    /**
+     * Use this prop to store additional data in the panel
+     */
+    additional?: any;
+
 }

package/src/types/side_entity_controller.tsx

@@ -1,6 +1,8 @@
 import { EntityCollection } from "./collections";
 import { ResolvedEntityCollection } from "./resolved_entities";
 import { Entity } from "./entities";
+import { EntityOverrides } from "./entity_overrides";
+import { EntityFormProps } from "../form";
 
 /**
  * Props used to open a side dialog
@@ -27,7 +29,7 @@ export interface EntitySidePanelProps<M extends Record<string, any> = any> {
      * Open the entity with a selected sub-collection view. If the panel for this
      * entity was already open, it is replaced.
      */
-    selectedSubPath?: string;
+    selectedTab?: string;
 
     /**
      * Use this prop to override the width of the form view.
@@ -65,6 +67,10 @@ export interface EntitySidePanelProps<M extends Record<string, any> = any> {
      */
     closeOnSave?: boolean;
 
+    /**
+     * Override some form properties
+     */
+    formProps?: Partial<EntityFormProps<M>>;
 }
 
 /**

package/src/types/storage.ts

@@ -6,6 +6,7 @@ export interface UploadFileProps {
     fileName?: string,
     path?: string,
     metadata?: any,
+    bucket?: string
 }
 
 /**
@@ -16,6 +17,10 @@ export interface UploadFileResult {
      * Storage path including the file name where the file was uploaded.
      */
     path: string;
+    /**
+     * Bucket where the file was uploaded
+     */
+    bucket: string;
 }
 
 /**
@@ -73,24 +78,110 @@ export interface StorageSource {
      * @param fileName
      * @param path
      * @param metadata
+     * @param bucket
      */
     uploadFile: ({
                      file,
                      fileName,
                      path,
-                     metadata
+                     metadata,
+                     bucket
                  }: UploadFileProps) => Promise<UploadFileResult>;
 
     /**
      * Convert a storage path or URL into a download configuration
      * @param path
+     * @param bucket
      */
-    getDownloadURL: (pathOrUrl: string) => Promise<DownloadConfig>;
+    getDownloadURL: (pathOrUrl: string, bucket?: string) => Promise<DownloadConfig>;
 
     /**
      * Get a file from a storage path.
      * It returns null if the file does not exist.
      * @param props
+     * @param bucket
+     */
+    getFile: (path: string, bucket?: string) => Promise<File | null>;
+
+    /**
+     * Delete a file.
+     * @param path
+     * @param bucket
+     */
+    deleteFile: (path: string, bucket?: string) => Promise<void>;
+
+    /**
+     * List the contents of a path.
+     * @param path
+     * @param options
+     */
+    list: (path: string, options?: {
+        bucket?: string,
+        maxResults?: number,
+        pageToken?: string
+    }) => Promise<StorageListResult>;
+
+}
+
+/**
+ * Result returned by list().
+ * @public
+ */
+export declare interface StorageListResult {
+    /**
+     * References to prefixes (sub-folders). You can call list() on them to
+     * get its contents.
+     *
+     * Folders are implicit based on '/' in the object paths.
+     * For example, if a bucket has two objects '/a/b/1' and '/a/b/2', list('/a')
+     * will return '/a/b' as a prefix.
+     */
+    prefixes: StorageReference[];
+    /**
+     * Objects in this directory.
+     * You can call getMetadata() and getDownloadUrl() on them.
+     */
+    items: StorageReference[];
+    /**
+     * If set, there might be more results for this list. Use this token to resume the list.
+     */
+    nextPageToken?: string;
+}
+
+/**
+ * Represents a reference to a Google Cloud Storage object. Developers can
+ * upload, download, and delete objects, as well as get/set object metadata.
+ * @public
+ */
+export declare interface StorageReference {
+    /**
+     * Returns a gs:// URL for this object in the form
+     *   `gs://<bucket>/<path>/<to>/<object>`
+     * @returns The gs:// URL.
+     */
+    toString(): string;
+
+    /**
+     * A reference to the root of this object's bucket.
+     */
+    root: StorageReference;
+    /**
+     * The name of the bucket containing this reference's object.
+     */
+    bucket: string;
+    /**
+     * The full path of this object.
+     */
+    fullPath: string;
+    /**
+     * The short name of this object, which is the last component of the full path.
+     * For example, if fullPath is 'full/path/image.png', name is 'image.png'.
+     */
+    name: string;
+
+    /**
+     * A reference pointing to the parent location of this reference, or null if
+     * this reference is the root.
      */
-    getFile: (path:string) => Promise<File | null>;
+    parent: StorageReference | null;
 }

package/src/types/user.ts

@@ -1,3 +1,5 @@
+import { Role } from "./roles";
+
 /**
  * This interface represents a user.
  * It has some of the same fields as a Firebase User.
@@ -34,4 +36,11 @@ export type User = {
      */
     readonly isAnonymous: boolean;
 
+    /**
+     *
+     */
+    roles?: Role[];
+
+    getIdToken?: (forceRefresh?: boolean) => Promise<string>;
+
 };

package/src/util/builders.ts

@@ -26,10 +26,12 @@ import {
  * @param collection
  * @group Builder
  */
-export function buildCollection<M extends Record<string, any> = any,
-    UserType extends User = User>(
-    collection: EntityCollection<M, UserType>
-): EntityCollection<M, UserType> {
+export function buildCollection<
+    M extends Record<string, any> = any,
+    USER extends User = User>
+(
+    collection: EntityCollection<M, USER>
+): EntityCollection<M, USER> {
     return collection;
 }
 
@@ -39,7 +41,7 @@ export function buildCollection<M extends Record<string, any> = any,
  * @param property
  * @group Builder
  */
-export function buildProperty<T extends CMSType = CMSType, P extends PropertyOrBuilder<T> = PropertyOrBuilder<T>, M extends Record<string, any> = Record<string, any>>(
+export function buildProperty<T extends CMSType = CMSType, P extends PropertyOrBuilder<T> = PropertyOrBuilder<T>, M extends Record<string, any> = any>(
     property: P
 ):
     P extends StringProperty ? StringProperty :
@@ -120,9 +122,9 @@ export function buildEntityCallbacks<M extends Record<string, any> = any>(
  * @param additionalFieldDelegate
  * @group Builder
  */
-export function buildAdditionalFieldDelegate<M extends Record<string, any>, UserType extends User = User>(
-    additionalFieldDelegate: AdditionalFieldDelegate<M, UserType>
-): AdditionalFieldDelegate<M, UserType> {
+export function buildAdditionalFieldDelegate<M extends Record<string, any>, USER extends User = User>(
+    additionalFieldDelegate: AdditionalFieldDelegate<M, USER>
+): AdditionalFieldDelegate<M, USER> {
     return additionalFieldDelegate;
 }
 

package/src/util/collections.ts

@@ -1,6 +1,8 @@
 import {
     DefaultSelectedViewBuilder,
     DefaultSelectedViewParams,
+    EntityCollection,
+    PermissionsBuilder,
     PropertiesOrBuilders,
     PropertyOrBuilder
 } from "../types";
@@ -48,3 +50,23 @@ export function resolveDefaultSelectedView(
         return defaultSelectedView(params);
     }
 }
+
+/**
+ * If a collection is not applying permissions, we apply the given permissionsBuilder.
+ * This is used to apply the role permissions to the collections, unless they are already
+ * applying permissions.
+ * @param collections
+ * @param permissionsBuilder
+ */
+export const applyPermissionsFunctionIfEmpty = (collections: EntityCollection[], permissionsBuilder?: PermissionsBuilder<any, any>): EntityCollection[] => {
+
+    return collections.map(collection => {
+        if (collection.permissions) {
+            return collection;
+        }
+        return ({
+            ...collection,
+            permissions: permissionsBuilder
+        });
+    });
+}

package/src/util/entities.ts

@@ -15,7 +15,7 @@ import {
 } from "../types";
 import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
 
-export function isReadOnly(property: Property | ResolvedProperty): boolean {
+export function isReadOnly(property: Property<any> | ResolvedProperty<any>): boolean {
     if (property.readOnly)
         return true;
     if (property.dataType === "date") {
@@ -40,20 +40,22 @@ export function getDefaultValuesFor<M extends Record<string, any>>(properties: P
     if (!properties) return {};
     return Object.entries(properties)
         .map(([key, property]) => {
+            if (!property) return {};
             const value = getDefaultValueFor(property as PropertyOrBuilder);
             return value === undefined ? {} : { [key]: value };
         })
         .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
 }
 
-export function getDefaultValueFor(property: PropertyOrBuilder) {
+export function getDefaultValueFor(property?: PropertyOrBuilder) {
+    if (!property) return undefined;
     if (isPropertyBuilder(property)) return undefined;
-    if (property.dataType === "map" && property.properties) {
+    if (property.defaultValue || property.defaultValue === null) {
+        return property.defaultValue;
+    } else 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);
     }
@@ -139,7 +141,7 @@ export function sanitizeData<M extends Record<string, any>>
     return result;
 }
 
-export function getReferenceFrom<M extends Record<string, any>>(entity: Entity<M>): EntityReference<M> {
+export function getReferenceFrom<M extends Record<string, any>>(entity: Entity<M>): EntityReference {
     return new EntityReference(entity.id, entity.path);
 }
 
@@ -152,6 +154,7 @@ export function traverseValuesProperties<M extends Record<string, any>>(
         .map(([key, property]) => {
             const inputValue = inputValues && (inputValues)[key];
             const updatedValue = traverseValueProperty(inputValue, property as Property, operation);
+            if (updatedValue === null) return null;
             if (updatedValue === undefined) return undefined;
             return ({ [key]: updatedValue });
         })

package/src/util/entity_actions.ts

@@ -0,0 +1,28 @@
+import { EntityAction } from "../types";
+
+const reservedKeys = ["edit", "copy", "delete"];
+
+export function mergeEntityActions(currentActions: EntityAction[], newActions: EntityAction[]): EntityAction[] {
+    // given the current actions, replace the ones with the same key
+    // and append the new ones
+    const updatedActions: EntityAction[] = [];
+    currentActions.forEach(action => {
+        const newAction = newActions.find(a => a.key === action.key);
+        if (newAction) {
+            const mergedAction = {
+                ...action,
+                ...newAction
+            }
+            updatedActions.push(mergedAction);
+        } else {
+            updatedActions.push(action);
+        }
+    });
+    newActions.forEach(action => {
+        if (!currentActions.find(a => a.key === action.key) && (!action.key || !reservedKeys.includes(action.key))) {
+            updatedActions.push(action);
+        }
+    });
+    return updatedActions;
+
+}

package/src/util/entity_cache.ts

@@ -0,0 +1,204 @@
+import { EntityReference, GeoPoint, Vector } from "../types";
+
+// Define a unique prefix for entity keys in localStorage to avoid key collisions
+const LOCAL_STORAGE_PREFIX = "entity_cache::";
+
+// In-memory cache to store entities for quick access
+const entityCache: Map<string, object> = new Map();
+
+// Check `localStorage` availability once during initialization
+const isLocalStorageAvailable = typeof localStorage !== "undefined";
+
+// Define custom replacer for JSON.stringify
+function customReplacer(key: string): any {
+
+    // @ts-ignore
+    const value = this[key];
+
+    // Handle Date objects
+    // @ts-ignore
+    if (value instanceof Date) {
+        return { __type: "Date", value: value.toISOString() };
+    }
+
+    // Handle EntityReference
+    // @ts-ignore
+    if (value instanceof EntityReference) {
+        return { __type: "EntityReference", id: value.id, path: value.path };
+    }
+
+    // Handle GeoPoint
+    // @ts-ignore
+    if (value instanceof GeoPoint) {
+        return { __type: "GeoPoint", latitude: value.latitude, longitude: value.longitude };
+    }
+
+    // Handle Vector
+    // @ts-ignore
+    if (value instanceof Vector) {
+        return { __type: "Vector", value: value.value };
+    }
+
+    return value;
+}
+
+// Define custom reviver for JSON.parse
+function customReviver(key: string, value: any): any {
+    if (value && typeof value === "object" && "__type" in value) {
+        switch (value.__type) {
+            case "Date":
+                return new Date(value.value);
+            case "EntityReference":
+                return new EntityReference(value.id, value.path);
+            case "GeoPoint":
+                return new GeoPoint(value.latitude, value.longitude);
+            case "Vector":
+                return new Vector(value.value);
+            default:
+                return value;
+        }
+    }
+    return value;
+}
+
+// Initialize the in-memory cache by loading entities from `localStorage`
+if (isLocalStorageAvailable) {
+    try {
+        // Iterate over all keys in localStorage to find those with the specified prefix
+        for (let i = 0; i < localStorage.length; i++) {
+            const fullKey = localStorage.key(i);
+            if (fullKey && fullKey.startsWith(LOCAL_STORAGE_PREFIX)) {
+                const path = fullKey.substring(LOCAL_STORAGE_PREFIX.length);
+                const entityString = localStorage.getItem(fullKey);
+                if (entityString) {
+                    try {
+                        const entity: object = JSON.parse(entityString, customReviver);
+                        entityCache.set(path, entity);
+                    } catch (parseError) {
+                        console.error(
+                            `Failed to parse entity for path "${path}" from localStorage:`,
+                            parseError
+                        );
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        console.error("Error accessing localStorage during initialization:", error);
+    }
+}
+
+/**
+ * Saves data to the in-memory cache and persists it individually in `localStorage`.
+ * @param path - The unique path/key for the data.
+ * @param data - The data to cache and persist.
+ */
+export function saveEntityToCache(path: string, data: object): void {
+    // Update the in-memory cache
+    entityCache.set(path, data);
+
+    // Persist the data individually in localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const key = LOCAL_STORAGE_PREFIX + path;
+            const entityString = JSON.stringify(data, customReplacer);
+            localStorage.setItem(key, entityString);
+        } catch (error) {
+            console.error(
+                `Failed to save entity for path "${path}" to localStorage:`,
+                error
+            );
+        }
+    }
+}
+
+/**
+ * Retrieves an entity from the in-memory cache or `localStorage`.
+ * If the entity is not in the cache but exists in `localStorage`, it loads it into the cache.
+ * @param path - The unique path/key for the entity.
+ * @returns The cached entity or `undefined` if not found.
+ */
+export function getEntityFromCache(path: string): object | undefined {
+
+    // Attempt to retrieve the entity from the in-memory cache
+    if (entityCache.has(path)) {
+        return entityCache.get(path);
+    }
+
+    // If not in the cache, attempt to load it from localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const key = LOCAL_STORAGE_PREFIX + path;
+            const entityString = localStorage.getItem(key);
+            if (entityString) {
+                const entity: object = JSON.parse(entityString, customReviver);
+                entityCache.set(path, entity); // Update the cache
+                return entity;
+            }
+        } catch (error) {
+            console.error(
+                `Failed to load entity for path "${path}" from localStorage:`,
+                error
+            );
+        }
+    }
+
+    // Entity not found
+    return undefined;
+}
+
+export function hasEntityInCache(path: string): boolean {
+    return entityCache.has(path);
+}
+
+/**
+ * Removes an entity from both the in-memory cache and `localStorage`.
+ * @param path - The unique path/key for the entity to remove.
+ */
+export function removeEntityFromCache(path: string): void {
+
+
+    console.debug("Removing entity from cache", path);
+
+    // Remove from the in-memory cache
+    entityCache.delete(path);
+
+    // Remove from localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const key = LOCAL_STORAGE_PREFIX + path;
+            localStorage.removeItem(key);
+        } catch (error) {
+            console.error(
+                `Failed to remove entity for path "${path}" from localStorage:`,
+                error
+            );
+        }
+    }
+}
+
+/**
+ * Clears the entire in-memory cache and removes all related entities from `localStorage`.
+ */
+export function clearEntityCache(): void {
+    // Clear the in-memory cache
+    entityCache.clear();
+
+    // Remove all entities with the specified prefix from localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const keysToRemove: string[] = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const fullKey = localStorage.key(i);
+                if (fullKey && fullKey.startsWith(LOCAL_STORAGE_PREFIX)) {
+                    keysToRemove.push(fullKey);
+                }
+            }
+
+            // Remove the keys after collecting them to avoid issues while iterating
+            keysToRemove.forEach((key) => localStorage.removeItem(key));
+        } catch (error) {
+            console.error("Failed to clear entity cache from localStorage:", error);
+        }
+    }
+}

package/src/util/enums.ts

@@ -22,7 +22,7 @@ export function enumToObjectEntries(enumValues: EnumValues): EnumValueConfig[] {
 }
 
 export function getLabelOrConfigFrom(enumValues: EnumValueConfig[], key?: string | number): EnumValueConfig | undefined {
-    if (!key) return undefined;
+    if (key === null || key === undefined) return undefined;
     return enumValues.find((entry) => String(entry.id) === String(key));
 }
 

package/src/util/icon_list.ts

@@ -1,17 +1,23 @@
-import { icon_synonyms } from "./icon_synonyms";
+import { iconSynonyms } from "./icon_synonyms";
 import { iconKeys } from "@firecms/ui";
+import Fuse from "fuse.js";
 
-// @ts-ignore
-import * as JsSearch from "js-search";
 
-export const iconsSearch = new JsSearch.Search("key");
-iconsSearch.addIndex("synonyms");
-
-iconsSearch.addDocuments(iconKeys
+const map = iconKeys
     .map((importName) => {
+        // @ts-ignore
+        const iconSynonym = importName in iconSynonyms ? iconSynonyms[importName] : "";
         return {
             key: importName,
-            // @ts-ignore
-            synonyms: icon_synonyms[importName] ?? [],
+            synonyms: iconSynonym,
         }
-    }));
+    });
+export const iconsSearch = new Fuse(map, {
+    isCaseSensitive: false,
+    shouldSort: true,
+    ignoreLocation: true,
+    distance: 0,
+    keys: ["key", "synonyms"]
+})
+
+