@rebasepro/common 0.0.1-canary.0

package/src/collections/CollectionRegistry.ts

@@ -0,0 +1,319 @@
+import {
+    EntityCollection,
+    NumberProperty,
+    Properties,
+    Property,
+    Relation,
+    RelationProperty,
+    StringProperty
+} from "@rebasepro/types";
+import { deepEqual } from "fast-equals";
+
+import { enumToObjectEntries, getSubcollections, removeFunctions, resolveCollectionRelations } from "../util";
+import cloneDeep from "lodash/cloneDeep.js";
+
+export class CollectionRegistry {
+
+    // Normalized runtime layer (used by Data Grid / UI)
+    private collectionsByDbPath = new Map<string, EntityCollection>();
+    private collectionsBySlug = new Map<string, EntityCollection>();
+    private rootCollections: EntityCollection[] = [];
+
+    // Raw configuration layer (used by Collection Editor AST generator)
+    private rawCollectionsByDbPath = new Map<string, EntityCollection>();
+    private rawCollectionsBySlug = new Map<string, EntityCollection>();
+    private rawRootCollections: EntityCollection[] = [];
+
+    // Snapshot of raw input for idempotency check — compared BEFORE normalization
+    // to avoid the issue where normalization creates new objects that always fail equality.
+    private lastRawInputSnapshot: ReturnType<typeof removeFunctions>[] | null = null;
+
+    constructor(collections?: EntityCollection[]) {
+        if (collections) {
+            this.registerMultiple(collections);
+        }
+    }
+
+    reset() {
+        this.collectionsByDbPath.clear();
+        this.collectionsBySlug.clear();
+        this.rootCollections = [];
+
+        this.rawCollectionsByDbPath.clear();
+        this.rawCollectionsBySlug.clear();
+        this.rawRootCollections = [];
+    }
+
+    /**
+     * Registers a collection and its subcollections recursively.
+     * Returns true if the collections have changed, false otherwise.
+     *
+     * Idempotent: compares the raw input (before normalization) against a stored
+     * snapshot. Only re-normalizes and re-registers when the raw input actually changed.
+     * @param collections
+     */
+    registerMultiple(collections: EntityCollection[]): boolean {
+        // Compare raw input BEFORE normalization to detect actual changes.
+        // This avoids the old issue where normalization creates new objects
+        // that always fail deep-equal even when the source data is identical.
+        const rawSnapshot = collections.map(c => removeFunctions(c));
+        if (this.lastRawInputSnapshot && deepEqual(this.lastRawInputSnapshot, rawSnapshot)) {
+            return false;
+        }
+
+        // Raw input has changed — normalize and register
+        this.reset();
+
+        const normalizedCollections = collections.map(c => this.normalizeCollection({ ...c }));
+        normalizedCollections.forEach((c, index) => this.register(c, collections[index]));
+
+        // Store the snapshot for future comparisons
+        this.lastRawInputSnapshot = rawSnapshot;
+
+        return true;
+    }
+
+    register(collection: EntityCollection, rawCollection?: EntityCollection) {
+        const raw = rawCollection ? cloneDeep(rawCollection) : cloneDeep(collection);
+
+        this.rootCollections.push(collection);
+        this.rawRootCollections.push(raw);
+
+        this._registerRecursively(collection, raw);
+    }
+
+    private _registerRecursively(collection: EntityCollection, rawCollection: EntityCollection) {
+        if (this.collectionsByDbPath.has(collection.dbPath)) {
+            return;
+        }
+
+        const normalizedCollection = this.normalizeCollection(collection);
+        this.collectionsByDbPath.set(normalizedCollection.dbPath, normalizedCollection);
+        this.rawCollectionsByDbPath.set(rawCollection.dbPath, rawCollection);
+
+        if (normalizedCollection.slug) {
+            this.collectionsBySlug.set(normalizedCollection.slug, normalizedCollection);
+        }
+        if (rawCollection.slug) {
+            this.rawCollectionsBySlug.set(rawCollection.slug, rawCollection);
+        }
+
+        const subcollections = getSubcollections(collection);
+        const rawSubcollections = getSubcollections(rawCollection);
+
+        if (subcollections && rawSubcollections) {
+            subcollections.forEach((subCollection, index) => {
+                this._registerRecursively(this.normalizeCollection(subCollection), cloneDeep(rawSubcollections[index]));
+            });
+        }
+    }
+
+    public normalizeCollection(collection: EntityCollection): EntityCollection {
+        const properties: Properties = this.normalizeProperties(collection.properties, collection.relations ?? []);
+
+        collection.properties = properties;
+        return collection;
+    }
+
+    private normalizeProperties(properties: Properties, relations: Relation[]): Properties {
+        const newProperties: Properties = {};
+        for (const key in properties) {
+            newProperties[key] = this.normalizeProperty(properties[key], relations);
+        }
+        return newProperties;
+    }
+
+    private normalizeProperty(property: Property, relations: Relation[]): Property {
+        const newProperty = { ...property };
+
+        if (newProperty.type === "map" && newProperty.properties) {
+            newProperty.properties = this.normalizeProperties(newProperty.properties, relations);
+        } else if (newProperty.type === "array") {
+            if (newProperty.of) {
+                newProperty.of = this.normalizeProperty(newProperty.of, relations);
+            } else if (newProperty.oneOf && newProperty.oneOf.properties) {
+                newProperty.oneOf.properties = this.normalizeProperties(newProperty.oneOf.properties, relations);
+            }
+        } else if ((newProperty.type === "string" || newProperty.type === "number") && newProperty.enum) {
+            const stringOrNumberProperty = newProperty as StringProperty | NumberProperty;
+            if (typeof stringOrNumberProperty.enum === "object" && !Array.isArray(stringOrNumberProperty.enum)) {
+                (stringOrNumberProperty as unknown as Record<string, unknown>).enum = enumToObjectEntries(stringOrNumberProperty.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? [];
+            }
+        } else if (newProperty.type === "relation") {
+            const relationProperty = newProperty as RelationProperty;
+            const relation = relations.find(r => r.relationName === relationProperty.relationName);
+            if (relation) {
+                // we attach the resolved relation to the property
+                (relationProperty as unknown as Record<string, unknown>).relation = relation;
+            } else {
+                console.warn(`Could not find relation for property with relationName: ${relationProperty.relationName}`);
+            }
+        }
+
+        return newProperty;
+    }
+
+    get(path: string): EntityCollection | undefined {
+        // First try slug lookup
+        const bySlug = this.collectionsBySlug.get(path);
+        if (bySlug) return bySlug;
+
+        // Fallback to dbPath lookup
+        return this.collectionsByDbPath.get(path);
+    }
+
+    /**
+     * Gets the pristine, un-normalized collection exactly as it was provided.
+     * Useful for the AST editor so it doesn't accidentally serialize injected metadata back to disk.
+     */
+    getRaw(path: string): EntityCollection | undefined {
+        const bySlug = this.rawCollectionsBySlug.get(path);
+        if (bySlug) return bySlug;
+        return this.rawCollectionsByDbPath.get(path);
+    }
+
+    /**
+     * Get collection by resolving multi-segment paths through relations
+     * e.g., "authors/70/posts" resolves to the posts collection
+     */
+    getCollectionByPath(collectionPath: string): EntityCollection | undefined {
+        // Handle simple single collection path
+        if (!collectionPath.includes("/")) {
+            return this.get(collectionPath);
+        }
+
+        // Handle multi-segment paths by resolving through relations
+        const pathSegments = collectionPath.split("/").filter(p => p);
+
+        if (pathSegments.length < 3 || pathSegments.length % 2 === 0) {
+            throw new Error(`Invalid relation path: ${collectionPath}. Expected format: collection/id/relation or collection/id/relation/id/relation`);
+        }
+
+        // Start with the root collection
+        const rootCollectionPath = pathSegments[0];
+        let currentCollection = this.get(rootCollectionPath);
+
+        if (!currentCollection) {
+            throw new Error(`Root collection not found: ${rootCollectionPath}`);
+        }
+
+        // Navigate through the path using relations
+        for (let i = 2; i < pathSegments.length; i += 2) {
+            const relationKey = pathSegments[i];
+
+            // Get relations for current collection
+            const resolvedRelations = resolveCollectionRelations(currentCollection);
+            const relation = resolvedRelations[relationKey];
+
+            if (!relation) {
+                throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug || currentCollection.dbPath}'`);
+            }
+
+            // Move to the target collection
+            currentCollection = relation.target();
+
+            // If there are more segments, continue navigation
+            if (i + 1 < pathSegments.length) {
+                // Skip entity ID segment
+            }
+        }
+
+        return currentCollection;
+    }
+
+    getCollections(): EntityCollection[] {
+        return Array.from(this.collectionsByDbPath.values());
+    }
+
+    getRawCollections(): EntityCollection[] {
+        return Array.from(this.rawCollectionsByDbPath.values());
+    }
+
+    /**
+     * Resolves a multi-segment path like "products/123/locales" and returns
+     * information about the collections and entity IDs along the path
+     */
+    resolvePathToCollections(path: string): {
+        collections: EntityCollection[],
+        entityIds: (string | number)[],
+        finalCollection: EntityCollection
+    } {
+        const pathSegments = path.split("/").filter(p => p);
+
+        if (pathSegments.length === 0) {
+            throw new Error(`Invalid path: ${path}`);
+        }
+
+        if (pathSegments.length % 2 !== 1) {
+            throw new Error(`Invalid collection path: ${path}. It must have an odd number of segments.`);
+        }
+
+        const collections: EntityCollection[] = [];
+        const entityIds: (string | number)[] = [];
+
+        // Start with the first collection
+        let currentCollection = this.get(pathSegments[0]);
+
+        if (!currentCollection) {
+            throw new Error(`Unknown collection path or slug: ${pathSegments[0]}`);
+        }
+
+        collections.push(currentCollection);
+
+        // Process the rest of the path in pairs (entityId, subcollectionSlug)
+        for (let i = 1; i < pathSegments.length; i += 2) {
+            const entityId = pathSegments[i];
+            entityIds.push(entityId);
+
+            if (i + 1 < pathSegments.length) {
+                const subcollectionSlug = pathSegments[i + 1];
+                const subcollections: EntityCollection[] | undefined = currentCollection.subcollections?.();
+                if (!subcollections) {
+                    throw new Error(`No subcollections found for ${currentCollection.slug || currentCollection.dbPath} in path: ${path}`);
+                }
+
+                const subcollection: EntityCollection | undefined = subcollections.find(c => c.slug === subcollectionSlug);
+                if (!subcollection) {
+                    throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug || currentCollection.dbPath}`);
+                }
+                currentCollection = subcollection;
+                collections.push(currentCollection);
+            }
+        }
+
+        return {
+            collections,
+            entityIds,
+            finalCollection: currentCollection
+        };
+    }
+
+}
+
+function areCollectionListsEqual(a: EntityCollection[], b: EntityCollection[]) {
+    // console.log("Comparing collection lists", a, b);
+    // return true;
+    if (a.length !== b.length) {
+        return false;
+    }
+    const aCopy = [...a];
+    const bCopy = [...b];
+    const aSorted = aCopy.sort((x, y) => x.slug.localeCompare(y.slug));
+    const bSorted = bCopy.sort((x, y) => x.slug.localeCompare(y.slug));
+    return aSorted.every((value, index) => areCollectionsEqual(value, bSorted[index]));
+}
+
+function areCollectionsEqual(a: EntityCollection, b: EntityCollection) {
+    const {
+        subcollections: subcollectionsA,
+        ...restA
+    } = a;
+    const {
+        subcollections: subcollectionsB,
+        ...restB
+    } = b;
+    if (!areCollectionListsEqual(subcollectionsA?.() ?? [], subcollectionsB?.() ?? [])) {
+        return false;
+    }
+    return deepEqual(removeFunctions(restA), removeFunctions(restB));
+}

package/src/collections/index.ts

@@ -0,0 +1 @@
+export * from "./CollectionRegistry";

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./util";
+export * from "./collections";

package/src/util/arrays.ts

@@ -0,0 +1,3 @@
+export function toArray<T>(input?: T | T[]): T[] {
+    return Array.isArray(input) ? input : (input ? [input] : []);
+}

package/src/util/builders.ts

@@ -0,0 +1,138 @@
+import {
+    AdditionalFieldDelegate,
+    ArrayProperty,
+    BooleanProperty,
+    DateProperty,
+    EntityCallbacks,
+    EntityCollection,
+    EnumValueConfig,
+    EnumValues,
+    GeopointProperty,
+    MapProperty,
+    NumberProperty, Properties,
+    Property,
+    PropertyConfig,
+    ReferenceProperty,
+    StringProperty,
+    User
+} from "@rebasepro/types";
+
+/**
+ * Identity function we use to defeat the type system of Typescript and build
+ * collection views with all its properties
+ * @param collection
+ * @group Builder
+ */
+export function buildCollection<
+    M extends Record<string, any> = any,
+    USER extends User = User>
+    (
+        collection: EntityCollection<M, USER>
+    ): EntityCollection<M, USER> {
+    return collection;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and preserve
+ * the property keys.
+ * @param property
+ * @group Builder
+ */
+export function buildProperty<T, P extends Property = Property>(
+    property: P
+):
+    P extends StringProperty ? StringProperty :
+    P extends NumberProperty ? NumberProperty :
+    P extends BooleanProperty ? BooleanProperty :
+    P extends DateProperty ? DateProperty :
+    P extends GeopointProperty ? GeopointProperty :
+    P extends ReferenceProperty ? ReferenceProperty :
+    P extends ArrayProperty ? ArrayProperty :
+    P extends MapProperty ? MapProperty : never {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return property as any;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and preserve
+ * the properties keys.
+ * @param properties
+ * @group Builder
+ */
+export function buildProperties<M extends Record<string, any>>(
+    properties: Properties
+): Properties {
+    return properties;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and preserve
+ * the properties keys.
+ * @param propertiesOrBuilder
+ * @group Builder
+ */
+export function buildPropertiesOrBuilder<M extends Record<string, any>>(
+    propertiesOrBuilder: Properties
+): Properties {
+    return propertiesOrBuilder;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and preserve
+ * the properties keys.
+ * @param enumValues
+ * @group Builder
+ */
+export function buildEnum(
+    enumValues: EnumValues
+): EnumValues {
+    return enumValues;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and preserve
+ * the properties keys.
+ * @param enumValueConfig
+ * @group Builder
+ */
+export function buildEnumValueConfig(
+    enumValueConfig: EnumValueConfig
+): EnumValueConfig {
+    return enumValueConfig;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and preserve
+ * the properties keys.
+ * @param callbacks
+ * @group Builder
+ */
+export function buildEntityCallbacks<M extends Record<string, any> = any>(
+    callbacks: EntityCallbacks<M>
+): EntityCallbacks<M> {
+    return callbacks;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and build
+ * additional field delegates views with all its properties
+ * @param additionalFieldDelegate
+ * @group Builder
+ */
+export function buildAdditionalFieldDelegate<M extends Record<string, any>, USER extends User = User>(
+    additionalFieldDelegate: AdditionalFieldDelegate<M, USER>
+): AdditionalFieldDelegate<M, USER> {
+    return additionalFieldDelegate;
+}
+
+/**
+ * Identity function we use to defeat the type system of Typescript and build
+ * additional field delegates views with all its properties
+ * @param propertyConfig
+ * @group Builder
+ */
+export function buildFieldConfig(
+    propertyConfig: PropertyConfig
+): PropertyConfig {
+    return propertyConfig;
+}

package/src/util/callbacks.ts

@@ -0,0 +1,115 @@
+import { EntityCallbacks, Properties } from "@rebasepro/types";
+import { mergeDeep } from "./objects";
+
+/**
+ * Helper function to recursively check if there are any callbacks in the properties.
+ */
+function hasPropertyCallbacks(properties: Properties, callbackName: "afterRead" | "beforeSave"): boolean {
+    if (!properties) return false;
+    for (const property of Object.values(properties)) {
+        if (property.callbacks?.[callbackName]) return true;
+        if (property.type === "map" && property.properties) {
+            if (hasPropertyCallbacks(property.properties, callbackName)) return true;
+        } else if (property.type === "array" && property.of) {
+            const ofs = Array.isArray(property.of) ? property.of : [property.of];
+            for (const of of ofs) {
+                if (of.callbacks?.[callbackName]) return true;
+                if (of.type === "map" && of.properties && hasPropertyCallbacks(of.properties, callbackName)) return true;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Recursively process properties to apply field-level hooks.
+ */
+async function processProperties(
+    properties: Properties,
+    values: Record<string, unknown>,
+    previousValues: Record<string, unknown>,
+    propsContext: unknown,
+    callbackName: "afterRead" | "beforeSave"
+): Promise<Record<string, unknown>> {
+    if (!values || typeof values !== "object") return values;
+
+    let result = { ...values };
+
+    for (const [key, property] of Object.entries(properties)) {
+        if (result[key] === undefined) continue;
+
+        let currentValue = result[key];
+        let previousValue = previousValues?.[key];
+
+        // 1. Array Property
+        if (property.type === "array" && Array.isArray(currentValue)) {
+            // We only support traversing single-type arrays for hooks currently to avoid complex union matching
+            if (property.of && !Array.isArray(property.of)) {
+                currentValue = await Promise.all(currentValue.map(async (item, index) => {
+                    const prevItem = Array.isArray(previousValue) ? previousValue[index] : undefined;
+                    // Mock a properties object to process a single item
+                    const singlePropData = { "_tmp": property.of } as Properties;
+                    const res = await processProperties(singlePropData, { "_tmp": item }, { "_tmp": prevItem }, propsContext, callbackName);
+                    return res["_tmp"];
+                }));
+            }
+        }
+        // 2. Map Property
+        else if (property.type === "map" && property.properties && typeof currentValue === "object") {
+            currentValue = await processProperties(property.properties, currentValue as Record<string, unknown>, (previousValue ?? {}) as Record<string, unknown>, propsContext, callbackName);
+        }
+
+        // 3. Property's own callback
+        if (property.callbacks?.[callbackName]) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const cbRes = await Promise.resolve(property.callbacks[callbackName]({
+                ...(propsContext as Record<string, unknown>),
+                value: currentValue,
+                previousValue
+            } as any));
+            if (cbRes !== undefined) {
+                currentValue = cbRes;
+            }
+        }
+
+        result[key] = currentValue;
+    }
+    return result;
+}
+
+/**
+ * Helper function to extract field-level PropertyCallbacks from a properties schema
+ * and wrap them into an EntityCallbacks object recursively.
+ */
+export const buildPropertyCallbacks = (properties: Properties): EntityCallbacks | undefined => {
+    if (!properties) return undefined;
+
+    const propertyCallbacks: EntityCallbacks = {};
+
+    if (hasPropertyCallbacks(properties, "afterRead")) {
+        propertyCallbacks.afterRead = async (props) => {
+            const processedValues = await processProperties(
+                properties,
+                props.entity.values as Record<string, unknown>,
+                props.entity.values as Record<string, unknown>,
+                props as unknown,
+                "afterRead"
+            );
+            return { ...props.entity, values: processedValues };
+        };
+    }
+
+    if (hasPropertyCallbacks(properties, "beforeSave")) {
+        propertyCallbacks.beforeSave = async (props) => {
+            return await processProperties(
+                properties,
+                props.values as Record<string, unknown>,
+                (props.previousValues ?? {}) as Record<string, unknown>,
+                props as unknown,
+                "beforeSave"
+            );
+        };
+    }
+
+    return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : undefined;
+};