@rebasepro/app 0.17.3 → 0.18.1

package/src/collections/navigation_from_path.ts

@@ -1,123 +0,0 @@
-
-type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = { key: string; [key: string]: unknown };
-import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
-import { getSubcollections } from "@rebasepro/common";
-import type { AdminCollection } from "@rebasepro/cms-types";
-
-export type NavigationViewInternal<M extends Record<string, unknown> = Record<string, unknown>> =
-    | NavigationViewEntityInternal<M>
-    | NavigationViewCollectionInternal<M>
-    | NavigationViewEntityCustomInternal<M>;
-
-export interface NavigationViewEntityInternal<M extends Record<string, unknown>> {
-    type: "entity";
-    entityId: string | number;
-    slug: string;
-    path: string;
-    parentCollection: AdminCollection<M>;
-}
-
-export interface NavigationViewCollectionInternal<M extends Record<string, unknown>> {
-    type: "collection";
-    id: string;
-    slug: string;
-    path: string;
-    collection: AdminCollection<M>;
-}
-
-export interface NavigationViewEntityCustomInternal<M extends Record<string, unknown>> {
-    type: "custom_view";
-    slug: string;
-    path: string;
-    entityId: string | number;
-    view: EntityCustomView<M>;
-}
-
-export function getNavigationEntriesFromPath(props: {
-    path: string,
-    collections: AdminCollection[] | undefined,
-    currentFullPath?: string,
-    contextEntityViews?: EntityCustomView[]
-}): 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 = collections && collections.find((entry) => entry.slug === subpathCombination);
-
-        if (collection) {
-            const collectionPath = currentFullPath && currentFullPath.length > 0
-                ? (currentFullPath + "/" + collection.slug)
-                : collection.slug;
-            result.push({
-                type: "collection",
-                id: collection.slug,
-                slug: collectionPath,
-                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 path = collectionPath + "/" + entityId;
-                result.push({
-                    type: "entity",
-                    entityId,
-                    slug: collectionPath,
-                    path,
-                    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((v): v is EntityCustomView => v != null)
-                        .find((entry) => entry.key === newPath);
-                    const subcollections = getSubcollections(collection);
-                    if (customView) {
-                        result.push({
-                            type: "custom_view",
-                            slug: collectionPath,
-                            entityId: entityId,
-                            path: path + "/" + customView.key,
-                            view: customView
-                        });
-                    } else if (subcollections) {
-                        result.push(...getNavigationEntriesFromPath({
-                            path: newPath,
-                            collections: subcollections,
-                            currentFullPath: path,
-                            contextEntityViews: props.contextEntityViews
-                        }));
-                    }
-                }
-            }
-            break;
-        }
-
-    }
-    return result;
-}
-
-function resolveEntityView(entityView: string | EntityCustomView, contextEntityViews?: EntityCustomView[]): EntityCustomView | undefined {
-    if (typeof entityView === "string") {
-        return contextEntityViews?.find((entry) => entry.key === entityView);
-    } else {
-        return entityView;
-    }
-}

package/src/collections/navigation_utils.ts

@@ -1,171 +0,0 @@
-
-
-import { getSubcollections } from "@rebasepro/common";
-import type { AdminCollection } from "@rebasepro/cms-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: AdminCollection[]): string {
-    let remainingPath = removeInitialAndTrailingSlashes(path);
-    if (!remainingPath) {
-        return "";
-    }
-
-    let currentCollections: AdminCollection[] | undefined = allCollections;
-    const resolvedPathParts: string[] = [];
-
-    while (remainingPath.length > 0) {
-        if (!currentCollections || currentCollections.length === 0) {
-            // We have remaining path segments but no more collections to match against
-            console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
-            resolvedPathParts.push(remainingPath);
-            remainingPath = ""; // Stop processing
-            break;
-        }
-
-        let foundMatch = false;
-        // Sort potential matches by length descending to prioritize longer matches (e.g., "a/b" over "a")
-        const potentialMatches: { col: AdminCollection; match: string; }[] = currentCollections
-            .flatMap(col => [{
-                col,
-                match: col.slug
-            }])
-            .filter(p => p.match && remainingPath.startsWith(p.match))
-            .sort((a, b) => b.match.length - a.match.length);
-
-        if (potentialMatches.length > 0) {
-            const {
-                col: foundCollection,
-                match: matchString
-            } = potentialMatches[0];
-
-            resolvedPathParts.push(foundCollection.slug); // Use the defined path
-            remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
-
-            // Check if we are at the end of the path
-            if (remainingPath.length === 0) {
-                foundMatch = true;
-                break; // Path ends with a collection segment
-            }
-
-            // The next segment must be a entity ID
-            const idSeparatorIndex = remainingPath.indexOf("/");
-            let entityId: string | number;
-            if (idSeparatorIndex > -1) {
-                entityId = remainingPath.substring(0, idSeparatorIndex);
-                remainingPath = remainingPath.substring(idSeparatorIndex + 1);
-            } else {
-                // This should not happen if the original path is valid (odd segments)
-                // but handle it defensively: assume the rest is the ID
-                entityId = remainingPath;
-                remainingPath = "";
-                console.warn(`resolveCollectionPathIds: Path seems to end with a entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
-                // Even if it ends here, we still need to push the ID
-            }
-
-            resolvedPathParts.push(entityId); // Append entity ID
-            currentCollections = getSubcollections(foundCollection); // Move to subcollections
-            foundMatch = true;
-
-            if (!currentCollections && remainingPath.length > 0) {
-                // Warn if the path continues but no subcollections were defined
-                console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.slug}" in path "${path}". Appending remaining original path.`);
-                resolvedPathParts.push(remainingPath); // Append the rest
-                remainingPath = ""; // Stop processing
-                break;
-            }
-
-        }
-
-        if (!foundMatch) {
-            // Collection definition not found for the start of the remaining path
-            console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
-            resolvedPathParts.push(remainingPath); // Append the rest
-            remainingPath = ""; // Stop processing
-            break;
-        }
-    }
-
-    return resolvedPathParts.join("/");
-}
-
-/**
- * Find the corresponding view at any depth for a given path.
- * Note that path or segments of the paths can be collection aliases.
- * @param slugOrPath
- * @param collections
- */
-export function getCollectionBySlugWithin(slugOrPath: string, collections: AdminCollection[]): AdminCollection | undefined {
-
-    const subpaths = removeInitialAndTrailingSlashes(slugOrPath).split("/");
-    if (subpaths.length % 2 === 0) {
-        throw Error(`getCollectionBySlug: Collection paths must have an odd number of segments: ${slugOrPath}`);
-    }
-
-    const subpathCombinations = getCollectionPathsCombinations(subpaths);
-    let result: AdminCollection | undefined;
-    for (let i = 0; i < subpathCombinations.length; i++) {
-        const subpathCombination = subpathCombinations[i];
-        const navigationEntry = collections && collections
-            .sort((a, b) => (a.slug ?? "").localeCompare(b.slug ?? ""))
-            .find((entry) => entry.slug === subpathCombination);
-
-        if (navigationEntry) {
-
-            if (subpathCombination === slugOrPath) {
-                result = navigationEntry;
-            } else if (getSubcollections(navigationEntry).length > 0) {
-                const newPath = slugOrPath.replace(subpathCombination, "").split("/").slice(2).join("/");
-                if (newPath.length > 0)
-                    result = getCollectionBySlugWithin(newPath, getSubcollections(navigationEntry));
-            }
-        }
-        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/collections/parent_references_from_path.ts

@@ -1,59 +0,0 @@
-import { EntityReference } from "@rebasepro/types";
-import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
-import { getSubcollections } from "@rebasepro/common";
-import type { AdminCollection } from "@rebasepro/cms-types";
-
-export function getParentReferencesFromPath(props: {
-    path: string,
-    collections: AdminCollection[] | 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: AdminCollection | undefined = collections && collections.find((entry) => entry.slug === subpathCombination);
-
-        // If we find a collection, we add the reference and continue
-        if (collection) {
-            const collectionPath = currentFullPath && currentFullPath.length > 0
-                ? (currentFullPath + "/" + collection.slug) // Use the current full path if provided
-                : collection.slug;
-
-            const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
-            const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];
-            if (nextSegments.length > 0) {
-                const entityId = nextSegments[0];
-                const path = collectionPath + "/" + entityId;
-                result.push(new EntityReference({ id: entityId,
-path: collectionPath }));
-                if (nextSegments.length > 1) {
-                    const newPath = nextSegments.slice(1).join("/");
-                    if (!collection) {
-                        throw Error("collection not found resolving path: " + collection);
-                    }
-                    if (getSubcollections(collection).length > 0) {
-                        result.push(...getParentReferencesFromPath({
-                            path: newPath,
-                            collections: getSubcollections(collection),
-                            currentFullPath: path
-                        }));
-                    }
-                }
-            }
-            break;
-        }
-
-    }
-    return result;
-}

package/src/collections/property-path.ts

@@ -1,30 +0,0 @@
-import type { Properties, Property } from "@rebasepro/types";
-
-/**
- * The property at a dotted path, walking `map` children — `address.street`.
- *
- * The value counterpart is `getValueInPath` in `@rebasepro/utils`; this is the
- * schema half, and the two have to be used together. Reading a dotted path off
- * an entity while looking its property up with a flat `properties[path]` gives
- * the value and `undefined` for how to render it, which is how a declared title
- * on a nested field silently fell back to a derived one.
- *
- * There were three copies of this: one private to `useColumnsIds`, one exported
- * from the admin layer, and the flat lookup in the title resolver that was not
- * this function at all. This is the one, in the lowest layer that needs it —
- * admin re-exports it under the name it already published.
- */
-export function getPropertyInPath(properties: Properties, path: string): Property | undefined {
-    if (typeof properties !== "object" || !properties) return undefined;
-    if (path in properties) {
-        return (properties as Record<string, Property>)[path];
-    }
-    if (path.includes(".")) {
-        const pathSegments = path.split(".");
-        const childProperty = (properties as Record<string, Property>)[pathSegments[0]];
-        if (typeof childProperty === "object" && childProperty?.type === "map" && childProperty.properties) {
-            return getPropertyInPath(childProperty.properties, pathSegments.slice(1).join("."));
-        }
-    }
-    return undefined;
-}

package/src/collections/property_presentation.ts

@@ -1,264 +0,0 @@
-/**
- * Property presentation helpers.
- *
- * These read a property's admin block — `readOnly`, `disabled.hidden`, the
- * declarative `conditions` — and lived in `@rebasepro/common`, which is on the
- * backend's dependency path. Nothing in core ever called them: `isReadOnly` and
- * `isHidden` are used only by the panel, and `applyPropertyConditions` has no
- * production caller at all.
- *
- * That last one is worth knowing about rather than assuming: the collection editor
- * has a whole Conditions UI, `serializable_utils` persists what it writes, and
- * `BaseProperty.conditions` documents itself as "evaluated at runtime like property
- * builders" — but the evaluator below is reached only from its own tests. It lives
- * here because here is where it would be called from once it is wired up.
- *
- * The one part of `conditions` that *is* applied is the literal case:
- * `hidden`/`readOnly`/`disabled` stated as a plain boolean rather than as a rule.
- * A literal needs no context, so `isHidden`/`isReadOnly`/`isDisabled` can answer
- * it directly, and those three gates are consulted everywhere a field is laid
- * out. A *rule* still is not evaluated anywhere in production — the split is
- * deliberate, not an oversight: it is the difference between a condition that
- * needs an entity to be evaluated against and one that does not.
- */
-import type { ConditionContext, ConditionRule, EnumValueConfig, Property, PropertyConditions, ReferenceProperty } from "@rebasepro/types";
-import type { AdminArrayOptions, AdminReferenceOptions } from "@rebasepro/cms-types";
-import { evaluateCondition } from "@rebasepro/common";
-
-/**
- * A condition stated as a literal rather than as a rule.
- *
- * `PropertyConditions` accepts either, and the two are answered in different
- * places: a rule needs a context and so can only be evaluated while rendering a
- * particular entity, but a literal is already the answer. Reading it here is
- * what makes `hidden: true` work without every gate below having to build a
- * condition context first — and without the caller reaching for
- * `{ "==": [1, 1] }` to say something it can say with a boolean.
- */
-function literalCondition(condition: ConditionRule | undefined): boolean {
-    return condition === true;
-}
-
-export function isReadOnly(property: Property): boolean {
-    if (property.admin?.readOnly)
-        return true;
-    if (literalCondition(property.conditions?.readOnly))
-        return true;
-    if (property.type === "date") {
-        if (property.autoValue)
-            return true;
-    }
-    if (property.type === "reference") {
-        return !property.path && !("Field" in (property.admin || {}) && property.admin?.Field);
-    }
-    return false;
-}
-
-export function isHidden(property: Property): boolean {
-    if (literalCondition(property.conditions?.hidden)) return true;
-    return typeof property.admin?.disabled === "object" && Boolean(property.admin?.disabled.hidden);
-}
-
-/**
- * Whether the field is disabled by its own declaration, ignoring form state.
- *
- * The `admin.disabled` block and `conditions.disabled: true` say the same thing
- * two ways, so every caller that gated on the first now asks here instead of
- * growing a second check of its own.
- */
-export function isDisabled(property: Property): boolean {
-    return Boolean(property.admin?.disabled) || literalCondition(property.conditions?.disabled);
-}
-
-export function applyPropertyConditions(
-    property: Property,
-    context: ConditionContext
-): Property {
-    const { conditions } = property;
-    if (!conditions) return property;
-
-    const result = { ...property };
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // FIELD STATE CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    // Evaluate disabled condition
-    if (conditions.disabled) {
-        const isDisabled = evaluateCondition(conditions.disabled, context);
-        if (isDisabled) {
-            result.admin = result.admin || {};
-            result.admin.disabled = {
-                clearOnDisabled: conditions.clearOnDisabled ?? false,
-                disabledMessage: conditions.disabledMessage,
-                hidden: false
-            };
-        }
-    }
-
-    // Evaluate hidden condition
-    if (conditions.hidden) {
-        const isHidden = evaluateCondition(conditions.hidden, context);
-        if (isHidden) {
-            result.admin = result.admin || {};
-            result.admin.disabled = {
-                ...(typeof result.admin?.disabled === "object" ? result.admin.disabled : {}),
-                hidden: true,
-                clearOnDisabled: conditions.clearOnDisabled ?? false
-            };
-        }
-    }
-
-    // Evaluate readOnly condition
-    if (conditions.readOnly) {
-        const isReadOnly = evaluateCondition(conditions.readOnly, context);
-        if (isReadOnly) {
-            result.admin = result.admin || {};
-            result.admin.readOnly = true;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // VALIDATION CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    // Evaluate required condition
-    if (conditions.required !== undefined) {
-        const isRequired = evaluateCondition(conditions.required, context) as boolean;
-        result.validation = {
-            ...result.validation,
-            required: isRequired as boolean | undefined,
-            requiredMessage: conditions.requiredMessage
-        };
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // VALUE CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    // Apply default value for new entities
-    if (context.isNew && conditions.defaultValue !== undefined) {
-        result.defaultValue = evaluateCondition(conditions.defaultValue, context) as Property["defaultValue"];
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // ENUM CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    if ("enum" in result && result.enum && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
-        (result as Record<string, unknown>).enum = applyEnumConditions(
-            result.enum as EnumValueConfig[],
-            conditions,
-            context
-        );
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // REFERENCE CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    if (result.type === "reference") {
-        if (conditions.referencePath) {
-            (result as ReferenceProperty).path = evaluateCondition(conditions.referencePath, context) as string;
-        }
-        if (conditions.referenceFilter) {
-            result.admin = result.admin || {};
-            (result.admin as AdminReferenceOptions).fixedFilter =
-                evaluateCondition(conditions.referenceFilter, context) as AdminReferenceOptions["fixedFilter"];
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // ARRAY CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    if (result.type === "array") {
-        if (conditions.canAddElements !== undefined) {
-            result.admin = result.admin || {};
-            (result.admin as AdminArrayOptions).canAddElements = evaluateCondition(conditions.canAddElements, context) as boolean;
-        }
-        if (conditions.sortable !== undefined) {
-            result.admin = result.admin || {};
-            (result.admin as AdminArrayOptions).sortable = evaluateCondition(conditions.sortable, context) as boolean;
-        }
-    }
-
-    return result;
-}
-
-/**
- * Convert an object with numeric keys back to an array.
- * Firestore stores arrays as {"0": "a", "1": "b"} to avoid nested arrays.
- */
-function objectToArray(obj: unknown): string[] {
-    if (Array.isArray(obj)) return obj.map(String);
-    if (obj && typeof obj === "object") {
-        const keys = Object.keys(obj);
-        if (keys.length > 0 && keys.every(k => !isNaN(Number(k)))) {
-            return keys
-                .sort((a, b) => Number(a) - Number(b))
-                .map(k => (obj as Record<string, unknown>)[k])
-                .filter((v): v is string => typeof v === "string" || typeof v === "number")
-                .map(String);
-        }
-    }
-    return [];
-}
-
-/**
- * Apply enum-specific conditions to filter and modify enum values.
- */
-function applyEnumConditions(
-    enumValues: EnumValueConfig[],
-    conditions: PropertyConditions,
-    context: ConditionContext
-): EnumValueConfig[] {
-    let result = [...enumValues];
-
-    // Apply allowedEnumValues filter
-    if (conditions.allowedEnumValues) {
-        const allowed = evaluateCondition(conditions.allowedEnumValues, context);
-        // Handle both array format and object-with-numeric-keys format (Firestore workaround)
-        const allowedArray = objectToArray(allowed);
-        if (allowedArray.length > 0) {
-            result = result.filter(ev => allowedArray.includes(String(ev.id)));
-        }
-    }
-
-    // Apply excludedEnumValues filter
-    if (conditions.excludedEnumValues) {
-        const excluded = evaluateCondition(conditions.excludedEnumValues, context);
-        // Handle both array format and object-with-numeric-keys format
-        const excludedArray = objectToArray(excluded);
-        if (excludedArray.length > 0) {
-            result = result.filter(ev => !excludedArray.includes(String(ev.id)));
-        }
-    }
-
-    // Apply individual enum conditions
-    if (conditions.enumConditions) {
-        result = result
-            .map(ev => {
-                const evConditions = conditions.enumConditions?.[ev.id];
-                if (!evConditions) return ev;
-
-                // Check hidden condition first
-                if (evConditions.hidden && evaluateCondition(evConditions.hidden, context)) {
-                    return null; // Will be filtered out
-                }
-
-                // Check disabled condition
-                if (evConditions.disabled && evaluateCondition(evConditions.disabled, context)) {
-                    return {
-                        ...ev,
-                        disabled: true
-                    };
-                }
-
-                return ev;
-            })
-            .filter((ev): ev is EnumValueConfig => ev !== null);
-    }
-
-    return result;
-}