@rebasepro/common 0.0.1-canary.0

package/src/util/entity_actions.ts

@@ -0,0 +1,28 @@
+import { EntityAction } from "@rebasepro/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/enums.ts

@@ -0,0 +1,26 @@
+import { EnumValueConfig, EnumValues } from "@rebasepro/types";
+
+export function enumToObjectEntries(enumValues: EnumValues): EnumValueConfig[] {
+    if (Array.isArray(enumValues)) {
+        return enumValues;
+    } else {
+        return Object.entries(enumValues).map(([id, value]) => {
+            if (typeof value === "string") {
+                return {
+                    id,
+                    label: value
+                }
+            } else {
+                return {
+                    ...value,
+                    id
+                }
+            }
+        });
+    }
+}
+
+export function getLabelOrConfigFrom(enumValues: EnumValueConfig[], key?: string | number): EnumValueConfig | undefined {
+    if (key === null || key === undefined) return undefined;
+    return enumValues.find((entry) => String(entry.id) === String(key));
+}

package/src/util/fields.ts

@@ -0,0 +1,28 @@
+import { DefaultFieldConfig } from "@rebasepro/types";
+
+export function isDefaultFieldConfigId(id: string): id is DefaultFieldConfig {
+    return ["text_field",
+        "multiline",
+        "markdown",
+        "url",
+        "email",
+        "switch",
+        "select",
+        "multi_select",
+        "number_input",
+        "number_select",
+        "multi_number_select",
+        "file_upload",
+        "multi_file_upload",
+        "reference_as_string",
+        "reference",
+        "multi_references",
+        "relation",
+        "date_time",
+        "group",
+        "key_value",
+        "repeat",
+        "custom_array",
+        "block"
+    ].includes(id);
+}

package/src/util/flatten_object.ts

@@ -0,0 +1,45 @@
+export function flattenObject(obj: Record<string, unknown>, parentKey = "") {
+    if (!obj) return obj;
+    return Object.keys(obj).reduce((flatObj, key) => {
+        const newKey = parentKey ? `${parentKey}.${key}` : key;
+
+        if (typeof obj[key] === "object" && obj[key] !== null) {
+            if (Array.isArray(obj[key])) {
+                obj[key].forEach((item: unknown, index: number) => {
+                    Object.assign(flatObj, flattenObject(item as Record<string, unknown>, `${newKey}[${index}]`));
+                });
+            } else {
+                Object.assign(flatObj, flattenObject(obj[key] as Record<string, unknown>, newKey));
+            }
+        } else {
+            flatObj[newKey] = obj[key];
+        }
+
+        return flatObj;
+    }, {} as { [key: string]: unknown });
+}
+
+
+// map from nested property key like "a.b.c" to the maximum array count found in a list of objects for that array
+export type ArrayValuesCount = Record<string, number>;
+
+export function getArrayValuesCount(array: Record<string, unknown>[]): ArrayValuesCount {
+    return array.reduce((acc: ArrayValuesCount, obj: Record<string, unknown>) => {
+        Object.entries(obj).forEach(([key, value]) => {
+            // proceed only if value is an array
+            if (Array.isArray(value)) {
+                acc[key] = Math.max(acc[key] || 0, value.length);
+            }
+
+            // handle nested object
+            if (typeof value === "object" && value !== null) {
+                const nested = getArrayValuesCount([value as Record<string, unknown>]);
+                Object.entries(nested).forEach(([nestedKey, nestedCount]) => {
+                    const compoundKey = `${key}.${nestedKey}`;
+                    acc[compoundKey] = Math.max(acc[compoundKey] || 0, nestedCount);
+                });
+            }
+        });
+        return acc;
+    }, {});
+}

package/src/util/hash.ts

@@ -0,0 +1,11 @@
+export function hashString(str: string): number {
+    let hash = 0;
+    let i;
+    let chr;
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return Math.abs(hash);
+}

package/src/util/index.ts

@@ -0,0 +1,26 @@
+export * from "./collections";
+export * from "./common";
+export * from "./entities";
+export * from "./strings";
+export * from "./dates";
+export * from "./enums";
+export * from "./objects";
+export * from "./paths";
+export * from "./regexp";
+export * from "./navigation_utils";
+export * from "./entity_actions";
+export * from "./fields";
+export * from "./resolutions";
+export * from "./permissions";
+export * from "./plurals";
+export * from "./references";
+export * from "./flatten_object";
+export * from "./navigation_from_path";
+export * from "./parent_references_from_path";
+export * from "./builders";
+export * from "./storage";
+export * from "./arrays";
+export * from "./callbacks";
+export * from "./hash";
+export * from "./relations";
+export * from "./conditions";

package/src/util/names.ts

@@ -0,0 +1,30 @@
+import { toSnakeCase } from "./strings";
+
+/**
+ * Generates a foreign key column name from a given string, typically a collection slug or name.
+ * It converts the name to snake_case, attempts to singularize it by removing a trailing 's'
+ * (a common convention for collection names), and appends '_id'.
+ *
+ * @param name The base name to convert to a foreign key.
+ * @returns A foreign key name in the format 'singular_name_id'.
+ *
+ * @example
+ * // returns "user_id"
+ * generateForeignKeyName("users")
+ *
+ * @example
+ * // returns "post_id"
+ * generateForeignKeyName("posts")
+ *
+ * @example
+ * // returns "product_id"
+ * generateForeignKeyName("Product")
+ *
+ */
+export function generateForeignKeyName(name: string): string {
+    const snakeCaseName = toSnakeCase(name);
+    // A simple heuristic to singularize a plural name, which is a common convention.
+    const singularName = snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName;
+    return `${singularName}_id`;
+}
+

package/src/util/navigation_from_path.ts

@@ -0,0 +1,121 @@
+import { EntityCollection, EntityCustomView } from "@rebasepro/types";
+import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
+import { getSubcollections } from "./resolutions";
+
+export type NavigationViewInternal<M extends Record<string, any> = any> =
+    | NavigationViewEntityInternal<M>
+    | NavigationViewCollectionInternal<M>
+    | NavigationViewEntityCustomInternal<M>;
+
+export interface NavigationViewEntityInternal<M extends Record<string, any>> {
+    type: "entity";
+    entityId: string | number;
+    slug: string;
+    path: string;
+    parentCollection: EntityCollection<M>;
+}
+
+export interface NavigationViewCollectionInternal<M extends Record<string, any>> {
+    type: "collection";
+    id: string;
+    slug: string;
+    path: string;
+    collection: EntityCollection<M>;
+}
+
+export interface NavigationViewEntityCustomInternal<M extends Record<string, any>> {
+    type: "custom_view";
+    slug: string;
+    path: string;
+    entityId: string | number;
+    view: EntityCustomView<M>;
+}
+
+export function getNavigationEntriesFromPath(props: {
+    path: string,
+    collections: EntityCollection[] | 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(Boolean)
+                        .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

@@ -0,0 +1,222 @@
+import { EntityCollection, CMSUrlController, SideEntityController } 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: EntityCollection[]): string {
+    let remainingPath = removeInitialAndTrailingSlashes(path);
+    if (!remainingPath) {
+        return "";
+    }
+
+    let currentCollections: EntityCollection[] | 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: EntityCollection; 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.dbPath); // 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 an 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 an 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: EntityCollection[]): EntityCollection | 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: EntityCollection | 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 (navigationEntry.subcollections) {
+                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;
+
+}
+
+export function navigateToEntity({
+    openEntityMode,
+    collection,
+    entityId,
+    copy,
+    path,
+    selectedTab,
+    sideEntityController,
+    onClose,
+    navigation
+}:
+
+    {
+        openEntityMode: "side_panel" | "full_screen";
+        collection?: EntityCollection;
+        entityId?: string | number;
+        selectedTab?: string;
+        copy?: boolean;
+        path: string;
+        sideEntityController: SideEntityController;
+        onClose?: () => void;
+        navigation: CMSUrlController
+    }) {
+
+    if (openEntityMode === "side_panel") {
+
+        sideEntityController.open({
+            entityId,
+            path: path,
+            copy,
+            selectedTab,
+            collection,
+            updateUrl: true,
+            onClose
+        });
+
+    } else {
+        let to = navigation.buildUrlCollectionPath(entityId ? `${path ?? path}/${entityId}` : path ?? path);
+        if (entityId && selectedTab) {
+            to += `/${selectedTab}`;
+        }
+        if (!entityId) {
+            to += "#new";
+        }
+        if (copy) {
+            to += "#copy";
+        }
+        navigation.navigate(to);
+    }
+
+}