@rebasepro/common 0.0.1-canary.0

package/src/util/relations.ts

@@ -0,0 +1,211 @@
+import { EntityCollection, Property, Relation } from "@rebasepro/types";
+import { toSnakeCase } from "./strings";
+import { generateForeignKeyName } from "./names";
+
+export function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): Relation {
+    if (!relation.target) {
+        throw new Error("Relation is missing a `target` collection.");
+    }
+    const targetCollection = relation.target();
+
+    const newRelation: Partial<Relation> = { ...relation };
+
+    // 1. Default relationName from target collection slug or dbPath
+    if (!newRelation.relationName) {
+        newRelation.relationName = toSnakeCase(targetCollection.slug ?? targetCollection.dbPath);
+    }
+
+    // 2. Infer or default direction if absent
+    if (!newRelation.direction) {
+        if (newRelation.foreignKeyOnTarget) newRelation.direction = "inverse";
+        else if (newRelation.through) newRelation.direction = "owning";
+        else if (newRelation.cardinality === "many") newRelation.direction = "inverse"; // Default has-many to be inverse
+        else newRelation.direction = "owning"; // Default all others to owning
+    }
+
+    // Do not default keys if a custom joinPath is provided; it's an advanced override.
+    if (!newRelation.joinPath) {
+        const sourceName = toSnakeCase(sourceCollection.slug ?? sourceCollection.name);
+
+        // 3. Default keys based on the relation type (cardinality and direction)
+        if (newRelation.cardinality === "one" && newRelation.direction === "owning") {
+            // Belongs-to / many-to-one
+            if (!newRelation.localKey) {
+                newRelation.localKey = generateForeignKeyName(newRelation.relationName);
+            }
+        } else if (newRelation.cardinality === "one" && newRelation.direction === "inverse") {
+            // Inverse one-to-one: the foreign key is on the target table pointing back to this collection
+            if (!newRelation.foreignKeyOnTarget) {
+                // First, try to find the corresponding owning relation's localKey on the target collection
+                let foundForeignKey = false;
+
+                try {
+                    // Look for an owning relation on the target that points back to this collection
+                    const targetRelations = targetCollection.relations || [];
+                    for (const targetRel of targetRelations) {
+                        if (targetRel.direction === "owning" &&
+                            targetRel.cardinality === "one" &&
+                            targetRel.localKey) {
+                            try {
+                                const targetRelTarget = targetRel.target();
+                                if (targetRelTarget.slug === sourceCollection.slug ||
+                                    targetRelTarget.dbPath === sourceCollection.dbPath) {
+                                    // Found the corresponding owning relation, use its localKey
+                                    newRelation.foreignKeyOnTarget = targetRel.localKey;
+                                    foundForeignKey = true;
+                                    break;
+                                }
+                            } catch (e) {
+                                // Continue looking if we can't resolve this target
+                                continue;
+                            }
+                        }
+                    }
+                } catch (e) {
+                    // If we can't inspect the target collection, fall back to naming convention
+                }
+
+                // If we couldn't find an explicit foreign key, fall back to naming convention
+                if (!foundForeignKey) {
+                    const keyPrefix = newRelation.inverseRelationName
+                        ? toSnakeCase(newRelation.inverseRelationName)
+                        : sourceName;
+                    newRelation.foreignKeyOnTarget = generateForeignKeyName(keyPrefix);
+                }
+            }
+        } else if (newRelation.cardinality === "many" && newRelation.direction === "inverse") {
+            // This could be either one-to-many or many-to-many inverse relation
+            // We need to check if there's a corresponding owning many-to-many relation
+
+            let isManyToManyInverse = false;
+
+            // Try to determine if this is a many-to-many inverse relation
+            if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) {
+                try {
+                    // Look for a corresponding owning many-to-many relation on the target collection
+                    const targetRelations = targetCollection.relations || [];
+                    for (const targetRel of targetRelations) {
+                        if (targetRel.cardinality === "many" &&
+                            targetRel.direction === "owning" &&
+                            targetRel.through &&
+                            (targetRel.relationName === newRelation.inverseRelationName)) {
+                            // Found a corresponding owning many-to-many relation
+                            isManyToManyInverse = true;
+                            break;
+                        }
+                    }
+                } catch (e) {
+                    // If we can't inspect the target collection, assume one-to-many
+                }
+            }
+
+            // Only add foreignKeyOnTarget for one-to-many inverse relations
+            if (!isManyToManyInverse && !newRelation.foreignKeyOnTarget) {
+                newRelation.foreignKeyOnTarget = generateForeignKeyName(sourceName);
+            }
+        } else if (newRelation.cardinality === "many" && newRelation.direction === "owning") {
+
+            // Many-to-many via junction table
+            const sourceTableName = getTableName(sourceCollection);
+            const targetTableName = getTableName(targetCollection);
+
+            newRelation.through = {
+                table: newRelation.through?.table ?? [sourceTableName, targetTableName].sort().join("_"),
+                sourceColumn: newRelation.through?.sourceColumn ?? generateForeignKeyName(sourceName),
+                targetColumn: newRelation.through?.targetColumn ?? generateForeignKeyName(newRelation.relationName),
+            };
+        }
+    }
+
+    // 4. Basic validation to catch configuration errors early
+    if (newRelation.cardinality === "one" && newRelation.direction === "owning" && !newRelation.localKey && !newRelation.joinPath) {
+        throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'owning' one-to-one relation requires a 'localKey'. Check the relation config for '${newRelation.relationName}'`);
+    }
+    if (newRelation.cardinality === "one" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) {
+        throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-one relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
+    }
+    if (newRelation.cardinality === "many" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) {
+        throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-many relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
+    }
+
+    return newRelation as Relation;
+}
+
+export function resolveCollectionRelations(
+    collection: EntityCollection,
+): Record<string, Relation> {
+    const relations: Record<string, Relation> = {};
+
+    // 1. Process explicit relations from the new `relations` field
+    if (collection.relations) {
+        collection.relations.forEach((relation) => {
+            const normalizedRelation = sanitizeRelation(relation, collection);
+            const relationKey = normalizedRelation.relationName;
+            if (relationKey) {
+                relations[relationKey] = normalizedRelation;
+            }
+        });
+    }
+
+    // 2. Process properties of type "relation"
+    if (collection.properties) {
+        Object.entries(collection.properties).forEach(([propKey, prop]) => {
+            const relation = resolvePropertyRelation({
+                propertyKey: propKey,
+                property: prop as Property,
+                sourceCollection: collection
+            });
+            if (relation) {
+                // Use property name as relation key if not already defined
+                if (!relations[propKey]) {
+                    // FIX: Set relationName to propKey if not defined, before normalizing
+                    if (!relation.relationName) {
+                        relation.relationName = propKey;
+                    }
+                    relations[propKey] = sanitizeRelation(relation, collection); // Already normalized in collection.relations
+                }
+            }
+        });
+    }
+
+    return relations;
+}
+
+export function resolvePropertyRelation({
+    propertyKey,
+    property,
+    sourceCollection
+}: {
+    propertyKey: string;
+    property: Property;
+    sourceCollection: EntityCollection;
+}): Relation | undefined {
+    if (property.type !== "relation") return undefined;
+
+    const relation = sourceCollection.relations?.find((rel) => rel.relationName === property.relationName)
+    if (!relation) {
+        console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug || sourceCollection.dbPath}'`);
+        return undefined;
+    }
+
+    return relation as Relation;
+
+}
+
+export function getTableName(collection: EntityCollection): string {
+    return collection.dbPath ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+}
+
+export function getTableVarName(tableName: string): string {
+    return tableName.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+export function getEnumVarName(tableName: string, propName: string): string {
+    const tableVar = getTableVarName(tableName);
+    const propVar = propName.charAt(0).toUpperCase() + propName.slice(1);
+    return `${tableVar}${propVar}`;
+}
+
+export function getColumnName(fullColumn: string): string {
+    return fullColumn.includes(".") ? fullColumn.split(".").pop()! : fullColumn;
+}

package/src/util/resolutions.ts

@@ -0,0 +1,383 @@
+import {
+    ArrayProperty,
+    AuthController,
+    CustomizationController,
+    EntityAction,
+    EntityCollection,
+    EntityCustomView,
+    EnumValueConfig,
+    EnumValues,
+    NumberProperty,
+    Properties,
+    Property,
+    PropertyConfig,
+    Relation,
+    RelationProperty,
+    StringProperty
+} from "@rebasepro/types";
+import { isDefaultFieldConfigId } from "./fields";
+import { isPropertyBuilder } from "./entities";
+import { getIn, mergeDeep } from "./objects";
+import { enumToObjectEntries } from "./enums";
+import { DEFAULT_ONE_OF_TYPE } from "./common";
+
+/**
+ * Resolve property builders, enums and arrays.
+ */
+
+export type ResolvePropertyProps<M extends Record<string, any> = any> = {
+    property: Property
+    propertyKey?: string,
+    values?: Partial<M>,
+    previousValues?: Partial<M>,
+    path?: string,
+    entityId?: string | number,
+    index?: number,
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+}
+
+export function resolveProperty<M extends Record<string, any> = any>(props: ResolvePropertyProps<M>): Property | null {
+
+    const {
+        property,
+        ignoreMissingFields = false,
+        ...rest
+    } = props;
+
+    let resultProperty: Property;
+
+    if (isPropertyBuilder(property)) {
+        const path = rest.path;
+        if (!path)
+            throw Error("Trying to resolve a property builder without specifying the entity path");
+
+        const usedPropertyValue = rest.propertyKey ? getIn(rest.values, rest.propertyKey) : undefined;
+        const dynamicProps = property.dynamicProps?.({
+            ...rest,
+            path,
+            propertyValue: usedPropertyValue,
+            values: rest.values ?? {},
+            previousValues: rest.previousValues ?? rest.values ?? {}
+        });
+        resultProperty = mergeDeep(property, dynamicProps ?? {});
+    } else {
+        resultProperty = property as Property;
+    }
+
+    // Apply dynamic properties if they exist
+    if (resultProperty.dynamicProps) {
+        const path = rest.path;
+        if (!path)
+            throw Error("Trying to resolve dynamicProps without specifying the entity path");
+
+        const usedPropertyValue = rest.propertyKey ? getIn(rest.values, rest.propertyKey) : undefined;
+        const dynamicPropsResult = resultProperty.dynamicProps({
+            ...rest,
+            path,
+            propertyValue: usedPropertyValue,
+            values: rest.values ?? {},
+            previousValues: rest.previousValues ?? rest.values ?? {}
+        });
+
+        if (dynamicPropsResult) {
+            resultProperty = mergeDeep(resultProperty, dynamicPropsResult);
+        }
+    }
+
+    let resolvedProperty: Property | null;
+
+    if (resultProperty?.type === "map" && resultProperty.properties) {
+        const properties = resolveProperties({
+            ignoreMissingFields,
+            ...rest,
+            properties: resultProperty.properties,
+        });
+        resolvedProperty = {
+            ...resultProperty,
+            properties
+        } as Property;
+    } else if (resultProperty?.type === "array") {
+        resolvedProperty = resultProperty;
+    } else if ((resultProperty?.type === "string" || resultProperty?.type === "number") && resultProperty.enum) {
+        resolvedProperty = resolvePropertyEnum(resultProperty);
+    } else {
+        resolvedProperty = resultProperty;
+    }
+
+    if (resolvedProperty?.propertyConfig && !isDefaultFieldConfigId(resolvedProperty.propertyConfig)) {
+        const cmsFields = rest.propertyConfigs;
+        if (!cmsFields && !ignoreMissingFields) {
+            throw Error(`Trying to resolve a property with key '${resolvedProperty.propertyConfig}' that inherits from a custom property config but no custom property configs were provided. Use the property 'propertyConfigs' in your app config to provide them`);
+        }
+        const customField: PropertyConfig | undefined = cmsFields?.[resolvedProperty.propertyConfig];
+        if (!customField) {
+            console.warn(`Trying to resolve a property with key '${resolvedProperty.propertyConfig}' that inherits from a custom property config but no custom property config with that key was found. Check the 'propertyConfigs' in your app config`)
+            return resolvedProperty;
+        }
+        if (customField.property) {
+            const { propertyConfig: _unused, ...restConfigProperty } = customField.property;
+            const customFieldProperty = resolveProperty({
+                property: { name: "", ...restConfigProperty } as Property,
+                ignoreMissingFields,
+                ...rest
+            });
+            if (customFieldProperty) {
+                resolvedProperty = mergeDeep(customFieldProperty, resolvedProperty);
+            }
+        }
+
+    }
+
+    return resolvedProperty;
+}
+
+export function resolveRelationProperty(property: RelationProperty, relations: Relation[]) {
+    // find the relation by name
+    const relation = relations.find((rel) => rel.relationName === property.relationName);
+    if (!relation) {
+        throw Error(`Relation ${property.relationName} not found`);
+    }
+    return {
+        ...property,
+        relation: relation
+    } as RelationProperty;
+
+}
+
+/**
+ * Resolve enum aliases for a string or number property
+ * @param property
+ */
+export function resolvePropertyEnum(property: StringProperty | NumberProperty): StringProperty | NumberProperty {
+    if (typeof property.enum === "object") {
+        return {
+            ...property,
+            enum: enumToObjectEntries(property.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? [],
+        };
+    }
+    return property as StringProperty | NumberProperty;
+}
+
+/**
+ * Resolve enums and arrays for properties
+ * @param properties
+ * @param value
+ */
+export function resolveProperties<M extends Record<string, any>>({
+    propertyKey,
+    properties,
+    ignoreMissingFields,
+    ...props
+}: {
+    propertyKey?: string,
+    properties: Properties,
+    values?: Partial<M>,
+    previousValues?: Partial<M>,
+    path?: string,
+    entityId?: string | number,
+    index?: number,
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+}): Properties {
+    return Object.entries<Property>(properties as Record<string, Property>)
+        .map(([key, property]) => {
+            const childResolvedProperty = resolveProperty({
+                propertyKey: propertyKey ? `${propertyKey}.${key}` : undefined,
+                property: property,
+                ignoreMissingFields,
+                ...props
+            });
+            if (!childResolvedProperty) return {};
+            return {
+                [key]: childResolvedProperty
+            };
+        })
+        .filter((a) => a !== null)
+        .reduce((a, b) => ({ ...a, ...b }), {}) as Properties;
+}
+
+export function resolveArrayProperties<M>({
+    propertyKey,
+    property,
+    ignoreMissingFields = false,
+    ...props
+}: {
+    propertyKey?: string,
+    property: ArrayProperty,
+    values?: Partial<M>,
+    previousValues?: Partial<M>,
+    path?: string,
+    entityId?: string | number,
+    index?: number,
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+}): Property[] {
+    const propertyValue = propertyKey ? getIn(props.values, propertyKey) : undefined;
+
+    if (property.of) {
+        if (Array.isArray(property.of)) {
+            return property.of.map((p, index) => {
+                return resolveProperty({
+                    propertyKey: `${propertyKey}.${index}`,
+                    property: p as Property,
+                    ignoreMissingFields,
+                    ...props,
+                    index,
+                });
+            }) as Property[];
+        } else {
+            const of = property.of;
+            const resolvedProperties = getArrayResolvedProperties({
+                propertyValue,
+                propertyKey,
+                property,
+                ignoreMissingFields,
+                ...props
+            });
+            const {
+                values,
+                previousValues,
+                ...rest
+            } = props;
+            const ofProperty = resolveProperty({ // we don't want to pass the values of the parent entity
+                property: of,
+                ignoreMissingFields,
+                ...rest
+            });
+            if (!ofProperty && !ignoreMissingFields)
+                throw Error("When using a property builder as the 'of' prop of an ArrayProperty, you must return a valid child property")
+            return resolvedProperties;
+        }
+    } else if (property.oneOf) {
+        const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+        const resolvedProperties: Property[] = Array.isArray(propertyValue)
+            ? propertyValue.map((v, index) => {
+                const type = v && v[typeField];
+                const childProperty = property.oneOf?.properties[type];
+                if (!type || !childProperty) return null;
+                return resolveProperty({
+                    propertyKey: `${propertyKey}.${index}`,
+                    property: childProperty,
+                    ignoreMissingFields,
+                    ...props
+                });
+            }).filter(e => Boolean(e)) as Property[]
+            : [];
+        return resolvedProperties;
+    } else if (!property.Field) {
+        throw Error(`The array property (${propertyKey}) needs to declare an 'of' or a 'oneOf' property, or provide a custom \`Field\` component`);
+    } else {
+        return [];
+    }
+
+}
+
+export function getArrayResolvedProperties({
+    propertyKey,
+    propertyValue,
+    property,
+    ...props
+}: {
+    propertyValue: unknown,
+    propertyKey?: string,
+    property: ArrayProperty,
+    ignoreMissingFields: boolean,
+    values?: object;
+    previousValues?: object;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    authController: AuthController;
+}) {
+
+    const of = property.of;
+    if (!of)
+        throw Error(
+            `Trying to resolve an array property (${propertyKey}) without providing an 'of' property`
+        )
+    return Array.isArray(propertyValue)
+        ? propertyValue.map((v: unknown, index: number) => {
+            return resolveProperty({
+                propertyKey: `${propertyKey}.${index}`,
+                property: Array.isArray(of) ? of[index] : of,
+                ...props,
+                index
+            });
+        }).filter(e => Boolean(e)) as Property[]
+        : [];
+}
+
+export function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined {
+    if (typeof input === "object") {
+        return Object.entries(input).map(([id, value]) =>
+        (typeof value === "string"
+            ? {
+                id,
+                label: value
+            }
+            : value));
+    } else if (Array.isArray(input)) {
+        return input as EnumValueConfig[];
+    } else {
+        return undefined;
+    }
+}
+
+export function resolveEntityView(entityView: string | EntityCustomView<any>, contextEntityViews?: EntityCustomView<any>[]): EntityCustomView<any> | undefined {
+    if (typeof entityView === "string") {
+        return contextEntityViews?.find((entry) => entry.key === entityView);
+    } else {
+        return entityView;
+    }
+}
+
+export function resolveEntityAction<M extends Record<string, any>>(
+    entityAction: string | EntityAction<M>,
+    contextEntityActions?: EntityAction<M>[]
+): EntityAction<M> | undefined {
+    if (typeof entityAction === "string") {
+        return contextEntityActions?.find((entry) => entry.key === entityAction);
+    } else {
+        return entityAction;
+    }
+}
+
+export function resolvedSelectedEntityView<M extends Record<string, any>>(
+    customViews: (string | EntityCustomView<M>)[] | undefined,
+    customizationController: CustomizationController,
+    selectedTab?: string,
+    canEdit?: boolean,
+) {
+    const resolvedEntityViews = customViews ? customViews
+        .map(e => resolveEntityView(e, customizationController.entityViews))
+        .filter((e): e is EntityCustomView<M> => Boolean(e))
+        // .filter((e) => canEdit || !e.includeActions)
+        : [];
+
+    const selectedEntityView = resolvedEntityViews.find(e => e.key === selectedTab);
+    const selectedSecondaryForm = customViews
+        && resolvedEntityViews.filter(e => e.includeActions).find(e => e.key === selectedTab);
+    return {
+        resolvedEntityViews,
+        selectedEntityView,
+        selectedSecondaryForm
+    };
+}
+
+export function getSubcollections<M extends Record<string, any> = any>(collection: EntityCollection<M>) {
+    const subcollections: EntityCollection<any>[] = [];
+    subcollections.push(...(collection.subcollections?.() ?? []));
+    subcollections.push(...((collection.relations ?? [])
+        .filter((rel) => rel.cardinality === "many")
+        .map(relation => {
+            const targetCollection = relation.target();
+            const overrides = relation.overrides;
+            return overrides ? mergeDeep(targetCollection, overrides) : targetCollection;
+        }) ?? []));
+    return subcollections;
+}