@firecms/core 3.4.0-canary.0ef7442 → 3.4.0-canary.2575a08

package/dist/types/collections.d.ts

@@ -439,6 +439,13 @@ export interface CollectionActionsProps<M extends Record<string, any> = any, USE
      * `users/1234/addresses`
      */
     path: string;
+    /**
+     * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
+     *
+     * Optional, and never derived by splitting `path` — a parent entity id may itself
+     * contain "/". Absent means "not known here", not "no slashes".
+     */
+    pathSegments?: string[];
     /**
      * Path of the last collection, like `addresses`
      */

package/dist/types/datasource.d.ts

@@ -208,6 +208,10 @@ export interface DataSource {
     initTextSearch?: (props: {
         context: FireCMSContext;
         path: string;
+        /**
+         * `path` split at its real segment boundaries, when known. Never derived from `path`.
+         */
+        pathSegments?: string[];
         collection: EntityCollection;
         parentCollectionIds?: string[];
     }) => Promise<boolean>;
@@ -325,6 +329,10 @@ export interface DataSourceDelegate {
     initTextSearch?: (props: {
         context: FireCMSContext;
         path: string;
+        /**
+         * `path` split at its real segment boundaries, when known. Never derived from `path`.
+         */
+        pathSegments?: string[];
         databaseId?: string;
         collection: EntityCollection;
         parentCollectionIds?: string[];

package/dist/types/entity_actions.d.ts

@@ -55,6 +55,12 @@ export type EntityActionClickProps<M extends object, USER extends User = User> =
     entity?: Entity<M>;
     context: FireCMSContext<USER>;
     fullPath?: string;
+    /**
+     * `fullPath` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`,
+     * when the caller knows them. Absent means "not known here" — never derived from
+     * `fullPath`, since a parent id may itself contain "/".
+     */
+    pathSegments?: string[];
     fullIdPath?: string;
     collection?: EntityCollection<M>;
     /**

package/dist/types/entity_callbacks.d.ts

@@ -69,6 +69,13 @@ export interface EntityOnFetchProps<M extends Record<string, any> = any, USER ex
      * Might contain unresolved aliases.
      */
     path: string;
+    /**
+     * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
+     *
+     * Optional, and never derived by splitting `path` — a parent entity id may itself
+     * contain "/". Absent means "not known here", not "no slashes".
+     */
+    pathSegments?: string[];
     /**
      * Fetched entity
      */
@@ -106,6 +113,13 @@ export interface EntityOnSaveProps<M extends Record<string, any> = any, USER ext
      * Might contain unresolved aliases.
      */
     path: string;
+    /**
+     * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
+     *
+     * Optional, and never derived by splitting `path` — a parent entity id may itself
+     * contain "/". Absent means "not known here", not "no slashes".
+     */
+    pathSegments?: string[];
     /**
      * Full path where this entity is being saved, with alias resolved
      */
@@ -144,6 +158,13 @@ export interface EntityOnDeleteProps<M extends Record<string, any> = any, USER e
      * Path of the parent collection
      */
     path: string;
+    /**
+     * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
+     *
+     * Optional, and never derived by splitting `path` — a parent entity id may itself
+     * contain "/". Absent means "not known here", not "no slashes".
+     */
+    pathSegments?: string[];
     /**
      * Deleted entity id
      */

package/dist/types/navigation.d.ts

@@ -48,8 +48,12 @@ export type NavigationController<EC extends EntityCollection = EntityCollection<
     /**
      * Get the collection configuration for a given path.
      * The collection is resolved from the given path or alias.
+     *
+     * Pass `pathSegments` when you have them: without them the path is split on "/" and
+     * asserted to have an odd number of parts, which a chain containing a slash-bearing
+     * entity id fails — it throws instead of resolving.
      */
-    getCollection: (pathOrId: string, includeUserOverride?: boolean) => EC | undefined;
+    getCollection: (pathOrId: string, includeUserOverride?: boolean, pathSegments?: string[]) => EC | undefined;
     /**
      * Get the top level collection configuration for a given id
      */
@@ -99,23 +103,48 @@ export type NavigationController<EC extends EntityCollection = EntityCollection<
     /**
      * Turn a path with collection ids into a resolved path.
      * The ids (typically used in urls) will be replaced with relative paths (typically used in database paths)
+     *
+     * Pass `pathSegments` whenever you have them. Without them this has to find the entity
+     * ids inside the flattened string by reading up to the next "/", which is wrong for any
+     * id that contains one — the chain then shifts by a segment and resolution fails.
+     *
      * @param pathWithAliases
+     * @param pathSegments `pathWithAliases` split at its real segment boundaries, if known
+     */
+    resolveIdsFrom: (pathWithAliases: string, pathSegments?: string[]) => string;
+    /**
+     * The segment-wise counterpart of {@link resolveIdsFrom}: replaces collection ids with
+     * their real paths while carrying every entity id through whole, slashes included.
+     *
+     * Idempotent — segments that are already resolved pass through unchanged.
+     *
+     * Optional so that a `navigationController` built against an earlier version keeps
+     * working: callers fall back to using the segments as given, which is what happened
+     * before this method existed. Controllers built by `useBuildNavigationController`
+     * always provide it.
+     *
+     * @param pathSegments
      */
-    resolveIdsFrom: (pathWithAliases: string) => string;
+    resolveSegmentsFrom?: (pathSegments: string[]) => string[];
     /**
      * Call this method to recalculate the navigation
      */
     refreshNavigation: () => void;
     /**
-     * Retrieve all the related parent references for a given path
+     * Retrieve all the related parent references for a given path.
+     *
+     * `path` is expected escaped, as it comes from the URL. Pass `pathSegments` when the
+     * path at hand is a raw datasource path, whose ids may contain a bare "/".
+     *
      * @param path
+     * @param pathSegments `path` split at its real segment boundaries, with raw ids
      */
-    getParentReferencesFromPath: (path: string) => EntityReference[];
+    getParentReferencesFromPath: (path: string, pathSegments?: string[]) => EntityReference[];
     /**
      * Retrieve all the related parent collection ids for a given path
      * @param path
      */
-    getParentCollectionIds: (path: string) => string[];
+    getParentCollectionIds: (path: string, pathSegments?: string[]) => string[];
     /**
      * Resolve paths from a list of ids
      * @param ids

package/dist/types/plugins.d.ts

@@ -121,18 +121,24 @@ export type FireCMSPlugin<PROPS = any, FORM_PROPS = any, EC extends EntityCollec
         blockSearch?: (props: {
             context: FireCMSContext;
             path: string;
+            /** `path` split at its real segment boundaries, when known. */
+            pathSegments?: string[];
             collection: EC;
             parentCollectionIds?: string[];
         }) => boolean;
         showTextSearchBar?: (props: {
             context: FireCMSContext;
             path: string;
+            /** `path` split at its real segment boundaries, when known. */
+            pathSegments?: string[];
             collection: EC;
             parentCollectionIds?: string[];
         }) => boolean;
         onTextSearchClick?: (props: {
             context: FireCMSContext;
             path: string;
+            /** `path` split at its real segment boundaries, when known. */
+            pathSegments?: string[];
             collection: EC;
             parentCollectionIds?: string[];
         }) => Promise<boolean>;
@@ -258,6 +264,13 @@ export interface PluginHomePageActionsProps<EP extends object = object, M extend
 export interface PluginFormActionProps<USER extends User = User, EC extends EntityCollection = EntityCollection> {
     entityId?: string;
     path: string;
+    /**
+     * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
+     *
+     * Optional, and never derived by splitting `path` — a parent entity id may itself
+     * contain "/". Absent means "not known here", not "no slashes".
+     */
+    pathSegments?: string[];
     parentCollectionIds: string[];
     status: EntityStatus;
     collection: EC;

package/dist/types/side_entity_controller.d.ts

@@ -17,8 +17,9 @@ export interface EntitySidePanelProps<M extends Record<string, any> = any> {
     fullIdPath?: string;
     /**
      * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
-     * Optional: when omitted the panel falls back to splitting `path`, which is correct for
-     * any backend whose entity ids cannot contain "/".
+     *
+     * Optional, and never derived by splitting `path` — a guess would be wrong in exactly
+     * the case the field exists for. Absent means "not known here", not "no slashes".
      */
     pathSegments?: string[];
     /**

package/dist/util/entity_cache.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Key identifying one entity in a cache.
+ *
+ * The id is escaped so that a `(path, entityId)` pair maps to exactly one key. Without it
+ * `("a", "b/c")` and `("a/b", "c")` both flatten to `"a/b/c"`, and one entity's cached
+ * values are served for the other.
+ *
+ * `encodeEntityId` is the identity for any id without "/", "?", "#" or "%", so this changes
+ * no key in an app whose ids cannot contain them.
+ */
+export declare function entityCacheKey(path: string | undefined, entityId: string | undefined): string;
 /**
  * Saves data to the in-memory cache and persists it individually in `localStorage`.
  * @param path - The unique path/key for the data.

package/dist/util/navigation_utils.d.ts

@@ -23,15 +23,97 @@ export declare function encodeEntityId(entityId: string): string;
  * @group Hooks and utilities
  */
 export declare function decodeEntityId(encodedEntityId: string): string;
+/**
+ * Segments of a subcollection sitting under the entity `entityId` of `parentPathSegments`.
+ *
+ * The parent entity id is kept whole however many slashes it contains, while the
+ * subcollection's own configured path is spread — a collection path never contains an
+ * entity id, so splitting that one is unambiguous.
+ *
+ * So `["test"] + "test/test" + "accommodation"` yields three segments,
+ * `["test", "test/test", "accommodation"]`, where splitting the flattened path
+ * `"test/test/test/accommodation"` would wrongly yield four.
+ *
+ * Returns undefined when the parent segments are unknown: the parent chain cannot be
+ * recovered from a flattened path, so there is nothing honest to build on.
+ *
+ * @group Hooks and utilities
+ */
+export declare function buildSubcollectionPathSegments(parentPathSegments: string[] | undefined, entityId: string | undefined, subcollectionPath: string): string[] | undefined;
 export declare function getLastSegment(path: string): string;
-export declare function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string;
+/**
+ * The outcome of walking a segment chain against a collection tree.
+ * @group Hooks and utilities
+ */
+export type PathSegmentsWalkStep = {
+    collection: EntityCollection;
+    /** Resolved path of this collection, e.g. `"products/pid/locales"`. */
+    collectionPath: string;
+    /** `collectionPath` split at its real segment boundaries. */
+    collectionSegments: string[];
+    /** The entity addressed inside it, when the chain continues past the collection. */
+    entityId?: string;
+};
+export type PathSegmentsWalk = {
+    /** Segments with every collection id replaced by the collection's real `path`. */
+    resolved: string[];
+    /** The collection the chain ends in, if the whole chain matched. */
+    collection?: EntityCollection;
+    /** One entry per collection level traversed, outermost first. */
+    steps: PathSegmentsWalkStep[];
+    /** The first segment that could not be matched, if the walk stopped early. */
+    unmatched?: string;
+};
+/**
+ * Walk a segment chain against a collection tree, matching a collection by either its
+ * `path` or its `id` and treating exactly one segment as each entity id.
+ *
+ * This is the primitive the string-based helpers cannot have: working on the flattened
+ * path they must *guess* where an entity id ends by reading up to the next "/", which is
+ * wrong for any id that contains one. Here the boundaries are given.
+ *
+ * Stops at the first segment it cannot match and reports it, rather than throwing.
+ *
+ * @group Hooks and utilities
+ */
+export declare function walkPathSegments(pathSegments: string[], allCollections: EntityCollection[]): PathSegmentsWalk;
+/**
+ * Resolve collection aliases in a segment array: every collection id is replaced by the
+ * collection's real `path`, and every entity id is carried through untouched.
+ *
+ * The segment-wise counterpart of {@link resolveCollectionPathIds}, and the reason it
+ * exists: that one works on the flattened string, so an entity id containing "/" shifts
+ * the rest of the chain by a segment and resolution fails with
+ * "Collection definition not found for segment starting with …".
+ *
+ * Matching accepts either a collection's `path` or its `id`, so already-resolved segments
+ * pass through unchanged — the function is idempotent.
+ *
+ * Mirrors the string version when a chain cannot be matched: it warns and carries the
+ * remainder through unresolved, rather than throwing.
+ *
+ * @group Hooks and utilities
+ */
+export declare function resolveCollectionPathSegments(pathSegments: string[], allCollections: EntityCollection[]): string[];
+/**
+ * Find the collection a segment chain addresses, whether it ends on the collection itself
+ * or on one of its entities.
+ *
+ * The segment-wise counterpart of {@link getCollectionByPathOrId}, which asserts an odd
+ * number of "/"-separated parts — an assertion a slash-bearing entity id fails, throwing
+ * where it should simply have resolved.
+ *
+ * @group Hooks and utilities
+ */
+export declare function getCollectionByPathSegments(pathSegments: string[], collections: EntityCollection[]): EntityCollection | undefined;
+export declare function resolveCollectionPathIds(path: string, allCollections: EntityCollection[], pathSegments?: string[]): string;
 /**
  * Find the corresponding view at any depth for a given path.
  * Note that path or segments of the paths can be collection aliases.
  * @param pathOrId
  * @param collections
  */
-export declare function getCollectionByPathOrId(pathOrId: string, collections: EntityCollection[]): EntityCollection | undefined;
+export declare function getCollectionByPathOrId(pathOrId: string, collections: EntityCollection[], pathSegments?: string[]): EntityCollection | undefined;
 /**
  * Get the subcollection combinations from a path:
  * "sites/es/locales" => ["sites/es/locales", "sites"]

package/dist/util/parent_references_from_path.d.ts

@@ -1,7 +1,22 @@
 import { EntityCollection, EntityReference } from "../types";
+/**
+ * References to every parent entity in a path.
+ *
+ * NOTE on encoding: `path` is expected ESCAPED, because it comes from the URL — the entity
+ * ids in it are decoded on the way out. Pass `pathSegments` instead whenever the path at
+ * hand is a raw datasource path (`entity.path`), which is not escaped and whose ids may
+ * therefore contain a bare "/": splitting that would silently produce the wrong references.
+ */
 export declare function getParentReferencesFromPath(props: {
     path: string;
     collections: EntityCollection[] | undefined;
     currentFullPath?: string;
     currentPathSegments?: string[];
+    /** `path` split at its real segment boundaries, with RAW ids. Takes precedence. */
+    pathSegments?: string[];
 }): EntityReference[];
+/**
+ * The segment-wise counterpart: the boundaries are given, so an entity id keeps its
+ * slashes and nothing has to be decoded.
+ */
+export declare function getParentReferencesFromPathSegments(pathSegments: string[], collections: EntityCollection[]): EntityReference[];

package/dist/util/paths.d.ts

@@ -9,6 +9,34 @@ export declare function segmentsToStrippedPath(paths: string[]): string;
 /**
  * Extract the collection path routes
  * `products/B44RG6APH/locales` => [`products`, `locales`]
+ *
+ * Finds the entity ids by position, which only works while no id contains "/" — with one,
+ * every following segment shifts and the wrong elements are kept. Use
+ * {@link collectionSegmentsFrom} when the real boundaries are known.
+ *
  * @param path
  */
 export declare function fullPathToCollectionSegments(path: string): string[];
+/**
+ * The collection chain of an already-segmented path:
+ * `['products', 'B44RG6APH', 'locales']` => [`products`, `locales`]
+ *
+ * The counterpart of {@link fullPathToCollectionSegments} for callers that know the real
+ * segment boundaries. Kept as a separate function rather than an extra parameter on that
+ * one: these helpers are small enough to be passed point-free, and `paths.map(fn)` would
+ * then hand the array index in as the new argument.
+ */
+export declare function collectionSegmentsFrom(pathSegments: string[]): string[];
+/**
+ * The historical, positional reading of a flattened path:
+ * `products/B44RG6APH/locales` => [`products`, `locales`]
+ *
+ * This produces a **collection chain**, not a datasource `pathSegments` value, and must
+ * never be used as one — see `path_segments_no_fabrication.test.ts`. It is only correct
+ * while no entity id contains "/", which is why every caller prefers real segments when
+ * they are available, and why it is named for what it assumes.
+ *
+ * It is still the right reading for a path that came from a URL, where entity ids arrive
+ * escaped and so cannot contain a bare "/".
+ */
+export declare function positionalCollectionSegments(path: string): string[];

package/dist/util/permissions.d.ts

@@ -1,5 +1,11 @@
 import { AuthController, Entity, EntityCollection, Permissions, User } from "../types";
-export declare function resolvePermissions<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): Permissions | undefined;
-export declare function canEditEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
-export declare function canCreateEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
-export declare function canDeleteEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
+/**
+ * `pathSegments` is `path` split at its real segment boundaries. It is forwarded so the
+ * collection chain handed to a permissions builder stays correct when an entity id contains
+ * "/" — splitting `path` positionally would keep the wrong elements. Optional everywhere:
+ * omitted, behaviour is exactly as before.
+ */
+export declare function resolvePermissions<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null, pathSegments?: string[]): Permissions | undefined;
+export declare function canEditEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null, pathSegments?: string[]): boolean;
+export declare function canCreateEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null, pathSegments?: string[]): boolean;
+export declare function canDeleteEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null, pathSegments?: string[]): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@firecms/core",
   "type": "module",
-  "version": "3.4.0-canary.0ef7442",
+  "version": "3.4.0-canary.2575a08",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/firecmsco"
@@ -53,8 +53,8 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",
     "@dnd-kit/sortable": "^10.0.0",
-    "@firecms/formex": "3.4.0-canary.0ef7442",
-    "@firecms/ui": "3.4.0-canary.0ef7442",
+    "@firecms/formex": "3.4.0-canary.2575a08",
+    "@firecms/ui": "3.4.0-canary.2575a08",
     "@floating-ui/dom": "^1.7.4",
     "@radix-ui/react-portal": "^1.1.10",
     "@radix-ui/react-slot": "^1.2.4",

package/src/components/DeleteEntityDialog.tsx

@@ -96,6 +96,8 @@ export function DeleteEntityDialog<M extends Record<string, any>>({
         deleteEntityWithCallbacks({
             dataSource,
             entity,
+            // The entity is the authority on where it lives; stated rather than left implicit.
+            pathSegments: entity.pathSegments,
             collection: resolvedCollection,
             callbacks,
             onDeleteSuccess,

package/src/components/EntityCollectionTable/EntityCollectionRowActions.tsx

@@ -3,7 +3,7 @@ import React, { MouseEvent, useCallback } from "react";
 import { CollectionSize, Entity, EntityAction, EntityCollection, SelectionController } from "../../types";
 import { Badge, Checkbox, cls, IconButton, Menu, MenuItem, MoreVertIcon, Skeleton, Tooltip } from "@firecms/ui";
 import { useFireCMSContext, useLargeLayout } from "../../hooks";
-import { getEntityFromCache } from "../../util/entity_cache";
+import { entityCacheKey, getEntityFromCache } from "../../util/entity_cache";
 import { getLocalChangesBackup } from "../../util";
 import { getChanges } from "../../form/EntityForm";
 
@@ -82,7 +82,7 @@ export const EntityCollectionRowActions = function EntityCollectionRowActions({
     const collapsedActions = actions.filter(a => a.collapsed || a.collapsed === undefined);
     const uncollapsedActions = actions.filter(a => a.collapsed === false);
     const enableLocalChangesBackup = collection ? getLocalChangesBackup(collection) : false;
-    const cachedData = enableLocalChangesBackup ? getEntityFromCache(fullPath + "/" + entity.id) : undefined;
+    const cachedData = enableLocalChangesBackup ? getEntityFromCache(entityCacheKey(fullPath, entity.id)) : undefined;
     const hasDraft = (() => {
         if (!cachedData || typeof cachedData !== "object" || Object.keys(cachedData).length === 0) return false;
         const realChanges = getChanges(cachedData as any, (entity?.values ?? {}) as any);

package/src/components/EntityCollectionView/EntityCollectionBoardView.tsx

@@ -274,6 +274,7 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
 
         currentDataSource.countEntities({
             path: fullPath,
+            pathSegments,
             collection: currentCollection
         }).then(count => {
             totalCount = count;
@@ -285,6 +286,7 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
 
         currentDataSource.countEntities({
             path: fullPath,
+            pathSegments,
             collection: currentCollection,
             filter: { [orderProperty]: ["!=", null] } as FilterValues<string>
         }).then(count => {
@@ -436,6 +438,8 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
 
         const saveProps: SaveEntityProps = {
             path: entity.path,
+            // Paired with `entity.path`: the segments the entity was loaded with.
+            pathSegments: entity.pathSegments,
             entityId: entity.id,
             values: updatedValues as M,
             previousValues: entity.values,
@@ -476,6 +480,7 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
             console.log("Fetching all documents from collection...");
             const allDocs = await dataSource.fetchCollection<M>({
                 path: fullPath,
+                pathSegments,
                 collection,
                 limit: 10000 // Fetch all
             });
@@ -496,6 +501,8 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
 
                 const saveProps: SaveEntityProps = {
                     path: entity.path,
+                    // Paired with `entity.path`: the segments the entity was loaded with.
+                    pathSegments: entity.pathSegments,
                     entityId: entity.id,
                     values: updatedValues as M,
                     previousValues: entity.values,
@@ -667,6 +674,7 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
                         });
                         sideEntityController.open({
                             path: fullPath,
+                            pathSegments,
                             collection,
                             entityId: undefined,
                             updateUrl: true,