@rebasepro/common 0.10.0 → 0.10.1-canary.0a881d4

package/src/util/resolutions.ts

@@ -1,6 +1,6 @@
 import {
     ArrayProperty,
-    AuthController,
+    AuthState,
     CollectionConfig,
     EnumValueConfig,
     EnumValues,
@@ -36,7 +36,7 @@ export type ResolvePropertyProps<M extends Record<string, unknown> = Record<stri
     index?: number,
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
-    authController: AuthController;
+    authController: AuthState;
 }
 
 export function resolveProperty<M extends Record<string, unknown> = Record<string, unknown>>(props: ResolvePropertyProps<M>): Property | null {
@@ -191,7 +191,7 @@ export function resolveProperties<M extends Record<string, unknown>>({
     index?: number,
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
-    authController: AuthController;
+    authController: AuthState;
 }): Properties {
     return Object.entries<Property>(properties as Record<string, Property>)
         .map(([key, property]) => {
@@ -226,7 +226,7 @@ export function resolveArrayProperties<M>({
     index?: number,
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
-    authController: AuthController;
+    authController: AuthState;
 }): Property[] {
     const propertyValue = propertyKey ? getIn(props.values, propertyKey) : undefined;
 
@@ -280,8 +280,16 @@ export function resolveArrayProperties<M>({
             }).filter(e => Boolean(e)) as Property[]
             : [];
         return resolvedProperties;
-    } else if (!("Field" in (property.ui || {}) && property.ui?.Field)) {
-        throw Error(`The array property (${propertyKey}) needs to declare an 'of' or a 'oneOf' property, or provide a custom \`Field\` component`);
+    } else if (!property.columnType) {
+        // An array with neither `of`/`oneOf` nor a `columnType` describes no element
+        // type, so nothing can be generated or rendered from it.
+        //
+        // The escape hatch used to be `ui.Field` — "a custom component can render
+        // anything" — which made a *presentation* field decide whether a schema was
+        // valid, in code the Postgres generator runs. `columnType` is the same escape
+        // hatch stated as data: `columnType: "text[]"` says what the column holds,
+        // which is what both the generator and the form actually need.
+        throw Error(`The array property (${propertyKey}) needs to declare an 'of' or a 'oneOf' property, or a \`columnType\` such as "text[]"`);
     } else {
         return [];
     }
@@ -304,7 +312,7 @@ export function getArrayResolvedProperties({
     entityId?: string | number;
     index?: number;
     propertyConfigs?: Record<string, PropertyConfig>;
-    authController: AuthController;
+    authController: AuthState;
 }) {
 
     const of = property.of;

package/dist/util/filter-operator-resolution.d.ts

@@ -1,32 +0,0 @@
-import { Property, WhereFilterOp } from "@rebasepro/types";
-export interface ResolveFilterOperatorsParams {
-    /**
-     * The property to filter on. For array properties, pass the **item**
-     * property (`property.of`) together with `isArray: true` — the same
-     * convention the filter field dispatchers use.
-     */
-    property: Property;
-    /** True when filtering an array of `property`. */
-    isArray?: boolean;
-    /**
-     * The engine backing the collection (`collection.engine`, e.g.
-     * `"postgres"`, `"firestore"`). Falls back to the default engine's
-     * capabilities when omitted.
-     */
-    engine?: string;
-}
-/**
- * Resolve which filter operators the UI should offer for a property.
- *
- * The result is the **intersection** of three sets:
- * 1. what the engine can execute — {@link DataSourceCapabilities.filterOperators}
- *    (e.g. Firestore cannot run the LIKE family);
- * 2. what makes sense for the property type (e.g. no `>` on booleans);
- * 3. the developer's optional narrowing — `property.ui.filterOperators`.
- *
- * Returns an empty array when the property is not filterable (either by
- * type, or because the developer disabled it with `filterOperators: []`).
- *
- * @group Models
- */
-export declare function resolveFilterOperators({ property, isArray, engine }: ResolveFilterOperatorsParams): WhereFilterOp[];

package/dist/util/navigation_from_path.d.ts

@@ -1,34 +0,0 @@
-import { CollectionConfig } from "@rebasepro/types";
-type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = {
-    key: string;
-    [key: string]: unknown;
-};
-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: CollectionConfig<M>;
-}
-export interface NavigationViewCollectionInternal<M extends Record<string, unknown>> {
-    type: "collection";
-    id: string;
-    slug: string;
-    path: string;
-    collection: CollectionConfig<M>;
-}
-export interface NavigationViewEntityCustomInternal<M extends Record<string, unknown>> {
-    type: "custom_view";
-    slug: string;
-    path: string;
-    entityId: string | number;
-    view: EntityCustomView<M>;
-}
-export declare function getNavigationEntriesFromPath(props: {
-    path: string;
-    collections: CollectionConfig[] | undefined;
-    currentFullPath?: string;
-    contextEntityViews?: EntityCustomView[];
-}): NavigationViewInternal[];
-export {};

package/dist/util/navigation_utils.d.ts

@@ -1,20 +0,0 @@
-import { CollectionConfig } from "@rebasepro/types";
-export declare function removeInitialAndTrailingSlashes(s: string): string;
-export declare function removeInitialSlash(s: string): string;
-export declare function removeTrailingSlash(s: string): string;
-export declare function addInitialSlash(s: string): string;
-export declare function getLastSegment(path: string): string;
-export declare function resolveCollectionPathIds(path: string, allCollections: CollectionConfig[]): 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 slugOrPath
- * @param collections
- */
-export declare function getCollectionBySlugWithin(slugOrPath: string, collections: CollectionConfig[]): CollectionConfig | undefined;
-/**
- * Get the subcollection combinations from a path:
- * "sites/es/locales" => ["sites/es/locales", "sites"]
- * @param subpaths
- */
-export declare function getCollectionPathsCombinations(subpaths: string[]): string[];

package/dist/util/parent_references_from_path.d.ts

@@ -1,6 +0,0 @@
-import { CollectionConfig, EntityReference } from "@rebasepro/types";
-export declare function getParentReferencesFromPath(props: {
-    path: string;
-    collections: CollectionConfig[] | undefined;
-    currentFullPath?: string;
-}): EntityReference[];

package/dist/util/references.d.ts

@@ -1,2 +0,0 @@
-import { CollectionConfig } from "@rebasepro/types";
-export declare function getEntityImagePreviewPropertyKey<M extends Record<string, unknown>>(collection: CollectionConfig<M>): string | undefined;

package/src/util/filter-operator-resolution.ts

@@ -1,81 +0,0 @@
-import {
-    ALL_WHERE_FILTER_OPS,
-    DataType,
-    getDataSourceCapabilities,
-    Property,
-    WhereFilterOp
-} from "@rebasepro/types";
-
-/**
- * Default operators offered per property type, before engine capabilities and
- * per-property narrowing are applied. These mirror what the built-in filter
- * fields can render.
- */
-const COMPARISON_OPS: readonly WhereFilterOp[] = ["==", "!=", ">", ">=", "<", "<="];
-const NULL_CHECK_OPS: readonly WhereFilterOp[] = ["is-null", "is-not-null"];
-const MEMBERSHIP_OPS: readonly WhereFilterOp[] = ["in", "not-in"];
-const PATTERN_OPS: readonly WhereFilterOp[] = ["like", "ilike", "not-like", "not-ilike"];
-
-const DEFAULT_OPS_BY_TYPE: Partial<Record<DataType, readonly WhereFilterOp[]>> = {
-    string: [...COMPARISON_OPS, ...MEMBERSHIP_OPS, ...PATTERN_OPS, ...NULL_CHECK_OPS],
-    number: [...COMPARISON_OPS, ...MEMBERSHIP_OPS, ...NULL_CHECK_OPS],
-    date: [...COMPARISON_OPS, ...NULL_CHECK_OPS],
-    boolean: ["==", "!=", ...NULL_CHECK_OPS],
-    reference: ["==", "!=", ...MEMBERSHIP_OPS, ...NULL_CHECK_OPS],
-    relation: ["==", "!=", ...MEMBERSHIP_OPS, ...NULL_CHECK_OPS]
-    // geopoint, map, vector, binary, array (as a container): not filterable
-    // through the generic filter UI.
-};
-
-/** Operators offered when the property is an *array of* a filterable type. */
-const ARRAY_OPS: readonly WhereFilterOp[] = ["array-contains", "array-contains-any"];
-
-export interface ResolveFilterOperatorsParams {
-    /**
-     * The property to filter on. For array properties, pass the **item**
-     * property (`property.of`) together with `isArray: true` — the same
-     * convention the filter field dispatchers use.
-     */
-    property: Property;
-    /** True when filtering an array of `property`. */
-    isArray?: boolean;
-    /**
-     * The engine backing the collection (`collection.engine`, e.g.
-     * `"postgres"`, `"firestore"`). Falls back to the default engine's
-     * capabilities when omitted.
-     */
-    engine?: string;
-}
-
-/**
- * Resolve which filter operators the UI should offer for a property.
- *
- * The result is the **intersection** of three sets:
- * 1. what the engine can execute — {@link DataSourceCapabilities.filterOperators}
- *    (e.g. Firestore cannot run the LIKE family);
- * 2. what makes sense for the property type (e.g. no `>` on booleans);
- * 3. the developer's optional narrowing — `property.ui.filterOperators`.
- *
- * Returns an empty array when the property is not filterable (either by
- * type, or because the developer disabled it with `filterOperators: []`).
- *
- * @group Models
- */
-export function resolveFilterOperators({
-    property,
-    isArray,
-    engine
-}: ResolveFilterOperatorsParams): WhereFilterOp[] {
-    const typeDefaults: readonly WhereFilterOp[] = isArray
-        ? ARRAY_OPS
-        : DEFAULT_OPS_BY_TYPE[property.type] ?? [];
-    if (typeDefaults.length === 0) return [];
-
-    const engineOps = new Set(getDataSourceCapabilities(engine).filterOperators ?? ALL_WHERE_FILTER_OPS);
-
-    const narrowing = property.ui?.filterOperators;
-    const narrowingSet = narrowing !== undefined ? new Set(narrowing) : undefined;
-
-    return typeDefaults.filter(op =>
-        engineOps.has(op) && (narrowingSet === undefined || narrowingSet.has(op)));
-}

package/src/util/navigation_from_path.ts

@@ -1,122 +0,0 @@
-import { CollectionConfig } from "@rebasepro/types";
-type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = { key: string; [key: string]: unknown };
-import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
-import { getSubcollections } from "./resolutions";
-
-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: CollectionConfig<M>;
-}
-
-export interface NavigationViewCollectionInternal<M extends Record<string, unknown>> {
-    type: "collection";
-    id: string;
-    slug: string;
-    path: string;
-    collection: CollectionConfig<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: CollectionConfig[] | 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/util/navigation_utils.ts

@@ -1,170 +0,0 @@
-import { CollectionConfig } from "@rebasepro/types";
-
-import { getSubcollections } from "./resolutions";
-
-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: CollectionConfig[]): string {
-    let remainingPath = removeInitialAndTrailingSlashes(path);
-    if (!remainingPath) {
-        return "";
-    }
-
-    let currentCollections: CollectionConfig[] | 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: CollectionConfig; 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: CollectionConfig[]): CollectionConfig | 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: CollectionConfig | 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/util/parent_references_from_path.ts

@@ -1,58 +0,0 @@
-import { CollectionConfig, EntityReference } from "@rebasepro/types";
-import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
-import { getSubcollections } from "./resolutions";
-
-export function getParentReferencesFromPath(props: {
-    path: string,
-    collections: CollectionConfig[] | 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: CollectionConfig | 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/util/references.ts

@@ -1,48 +0,0 @@
-import { CollectionConfig } from "@rebasepro/types";
-
-export function getEntityImagePreviewPropertyKey<M extends Record<string, unknown>>(collection: CollectionConfig<M>): string | undefined {
-
-    // find first storage property of type image
-    for (const key in collection.properties) {
-        const property = collection.properties[key];
-        if (property.type === "string" && property.storage?.acceptedFiles?.includes("image/*")) {
-            return key;
-        }
-    }
-    // alternatively, look for the first array of images
-    for (const key in collection.properties) {
-        const property = collection.properties[key];
-        if (property.type === "array" && !Array.isArray(property.of) && property.of?.type === "string" && property.of.storage?.acceptedFiles?.includes("image/*")) {
-            return key;
-        }
-    }
-    // also check for URL properties with image preview type
-    for (const key in collection.properties) {
-        const property = collection.properties[key];
-        if (property.type === "string" && property.ui?.url === "image") {
-            return key;
-        }
-    }
-    // and arrays of URL properties with image preview type
-    for (const key in collection.properties) {
-        const property = collection.properties[key];
-        if (property.type === "array" && property.of && !Array.isArray(property.of) && property.of.type === "string" && property.of.ui?.url === "image") {
-            return key;
-        }
-    }
-    // fallback: any storage property without explicit acceptedFiles (e.g. a generic "picture" field)
-    for (const key in collection.properties) {
-        const property = collection.properties[key];
-        if (property.type === "string" && property.storage && !property.storage.acceptedFiles) {
-            return key;
-        }
-    }
-    // fallback: any array of storage properties without explicit acceptedFiles
-    for (const key in collection.properties) {
-        const property = collection.properties[key];
-        if (property.type === "array" && !Array.isArray(property.of) && property.of?.type === "string" && property.of.storage && !property.of.storage.acceptedFiles) {
-            return key;
-        }
-    }
-    return undefined;
-}