@rebasepro/common 0.0.1-canary.0

package/src/util/collections.ts

@@ -0,0 +1,126 @@
+import {
+    DefaultSelectedViewBuilder,
+    DefaultSelectedViewParams,
+    EntityCollection,
+    Properties,
+    Property,
+} from "@rebasepro/types";
+import { isPropertyBuilder } from "./entities";
+
+export function sortProperties<M extends Record<string, any>>(properties: Properties, propertiesOrder?: string[]): Properties {
+    try {
+        const propertiesKeys = Object.keys(properties);
+        // If no propertiesOrder, just use the original keys order
+        if (!propertiesOrder || propertiesOrder.length === 0) {
+            return propertiesKeys
+                .map((key) => {
+                    const property = properties[key] as Property;
+                    if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) {
+                        return ({
+                            [key]: {
+                                ...property,
+                                properties: sortProperties(property.properties, property.propertiesOrder)
+                            }
+                        });
+                    } else {
+                        return ({ [key]: property });
+                    }
+                })
+                .reduce((a: Properties, b: Properties) => ({ ...a, ...b }), {}) as Properties;
+        }
+
+        // Filter propertiesOrder to only include TOP-LEVEL property keys that exist
+        // (ignore nested keys like "data.mode" - they are for column ordering, not property filtering)
+        const validOrderKeys = (propertiesOrder as string[]).filter(key => {
+            // Only include top-level keys (no dots) that exist in properties
+            return !key.includes(".") && properties[key];
+        });
+
+        // Track which properties we've processed
+        const processedKeys = new Set<string>(validOrderKeys);
+
+        // Build result starting with ordered properties
+        const orderedResult = validOrderKeys
+            .map((key) => {
+                const property = properties[key] as Property;
+                if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) {
+                    return ({
+                        [key]: {
+                            ...property,
+                            properties: sortProperties(property.properties, property.propertiesOrder)
+                        }
+                    });
+                } else {
+                    return ({ [key]: property });
+                }
+            })
+            .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as Properties;
+
+        // Append any properties that were NOT in propertiesOrder (so they don't disappear!)
+        const missingProperties = propertiesKeys
+            .filter(key => !processedKeys.has(key))
+            .map((key) => {
+                const property = properties[key] as Property;
+                if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) {
+                    return ({
+                        [key]: {
+                            ...property,
+                            properties: sortProperties(property.properties, property.propertiesOrder)
+                        }
+                    });
+                } else {
+                    return ({ [key]: property });
+                }
+            })
+            .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as Properties;
+
+        return { ...orderedResult, ...missingProperties };
+    } catch (e) {
+        console.error("Error sorting properties", e);
+        return properties;
+    }
+}
+
+export function resolveDefaultSelectedView(
+    defaultSelectedView: string | DefaultSelectedViewBuilder | undefined,
+    params: DefaultSelectedViewParams
+) {
+    if (!defaultSelectedView) {
+        return undefined;
+    } else if (typeof defaultSelectedView === "string") {
+        return defaultSelectedView;
+    } else {
+        return defaultSelectedView(params);
+    }
+}
+
+
+
+export function getLocalChangesBackup(collection: EntityCollection) {
+    if (!collection.localChangesBackup) {
+        return "manual_apply";
+    }
+
+    return collection.localChangesBackup;
+}
+
+/**
+ * Returns the primary keys for an entity collection by inspecting the properties
+ * and finding any properties with `isId`.
+ * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
+ * @param collection
+ */
+export function getPrimaryKeys<M extends Record<string, any>>(collection: EntityCollection<M>): Extract<keyof M, string>[] {
+    const properties = collection.properties;
+    if (!properties) {
+        return ["id"] as Extract<keyof M, string>[];
+    }
+    const ids = Object.entries(properties)
+        .filter(([key, prop]) => typeof prop === "object" && prop !== null && "isId" in prop && Boolean(prop.isId))
+        .map(([key]) => key);
+
+    if (ids.length > 0) {
+        return ids as Extract<keyof M, string>[];
+    }
+    return ["id"] as Extract<keyof M, string>[];
+}

package/src/util/common.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_ONE_OF_TYPE = "type"
+export const DEFAULT_ONE_OF_VALUE = "value"

package/src/util/conditions.ts

@@ -0,0 +1,348 @@
+import jsonLogic from "json-logic-js";
+import {
+    ArrayProperty,
+    AuthController,
+    ConditionContext,
+    EnumValueConfig,
+    JsonLogicRule,
+    NumberProperty,
+    PropertyConditions,
+    Property,
+    ReferenceProperty,
+    StringProperty
+} from "@rebasepro/types";
+
+/**
+ * Access a nested property from an object via dot notation.
+ */
+function getIn(obj: Record<string, unknown> | unknown, path: string): unknown {
+    if (!obj || !path) return undefined;
+    return path.split('.').reduce((acc: unknown, part: string) => acc && (acc as Record<string, unknown>)[part], obj);
+}
+
+let operationsRegistered = false;
+
+/**
+ * Register custom JSON Logic operations for Rebase.
+ * Call this once at app initialization.
+ */
+export function registerConditionOperations(): void {
+    if (operationsRegistered) return;
+
+    // Check if user has a specific role by ID
+    jsonLogic.add_operation("hasRole", function (this: ConditionContext, roleId: string) {
+        return this?.user?.roles?.includes(roleId) ?? false;
+    });
+
+    // Check if user has any of the specified roles
+    jsonLogic.add_operation("hasAnyRole", function (this: ConditionContext, roleIds: string[]) {
+        if (!this?.user?.roles || !Array.isArray(roleIds)) return false;
+        return roleIds.some(role => this.user.roles.includes(role));
+    });
+
+    // Check if a timestamp is today
+    jsonLogic.add_operation("isToday", (timestamp: number) => {
+        if (!timestamp) return false;
+        const date = new Date(timestamp);
+        const today = new Date();
+        return date.getFullYear() === today.getFullYear() &&
+            date.getMonth() === today.getMonth() &&
+            date.getDate() === today.getDate();
+    });
+
+    // Check if a timestamp is in the past
+    jsonLogic.add_operation("isPast", (timestamp: number) => {
+        if (!timestamp) return false;
+        return timestamp < Date.now();
+    });
+
+    // Check if a timestamp is in the future
+    jsonLogic.add_operation("isFuture", (timestamp: number) => {
+        if (!timestamp) return false;
+        return timestamp > Date.now();
+    });
+
+    operationsRegistered = true;
+}
+
+/**
+ * Evaluate a JSON Logic rule against the given context.
+ */
+export function evaluateCondition(rule: JsonLogicRule, context: ConditionContext): unknown {
+    // Ensure operations are registered
+    registerConditionOperations();
+    return jsonLogic.apply(rule, context);
+}
+
+/**
+ * Convert a value to a format suitable for JSON Logic evaluation.
+ * Specifically handles Date objects by converting them to Unix timestamps.
+ */
+function serializeValueForConditions(value: unknown): unknown {
+    if (value === null || value === undefined) {
+        return value;
+    }
+
+    // Handle Date objects
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+
+    // Handle Firestore Timestamp-like objects (have toDate or toMillis)
+    if (typeof (value as { toMillis?: () => number })?.toMillis === "function") {
+        return (value as { toMillis: () => number }).toMillis();
+    }
+    if (typeof (value as { toDate?: () => Date })?.toDate === "function") {
+        return (value as { toDate: () => Date }).toDate().getTime();
+    }
+
+    // Handle arrays recursively
+    if (Array.isArray(value)) {
+        return value.map(serializeValueForConditions);
+    }
+
+    // Handle plain objects recursively
+    if (typeof value === "object") {
+        const result: Record<string, unknown> = {};
+        for (const key of Object.keys(value as Record<string, unknown>)) {
+            result[key] = serializeValueForConditions((value as Record<string, unknown>)[key]);
+        }
+        return result;
+    }
+
+    return value;
+}
+
+/**
+ * Build a ConditionContext from the current property resolution context.
+ */
+export function buildConditionContext(params: {
+    propertyKey?: string;
+    values?: Record<string, unknown>;
+    previousValues?: Record<string, unknown>;
+    path: string;
+    entityId?: string;
+    index?: number;
+    authController: AuthController;
+}): ConditionContext {
+    const {
+        propertyKey,
+        values,
+        previousValues,
+        path,
+        entityId,
+        index,
+        authController
+    } = params;
+
+    const user = authController.user;
+    const serializedValues = serializeValueForConditions(values ?? {});
+    const serializedPreviousValues = serializeValueForConditions(previousValues ?? values ?? {});
+
+    return {
+        values: serializedValues as Record<string, unknown>,
+        previousValues: serializedPreviousValues as Record<string, unknown>,
+        propertyValue: propertyKey ? getIn(serializedValues, propertyKey) : undefined,
+        path,
+        entityId,
+        isNew: !entityId,
+        index,
+        user: {
+            uid: user?.uid ?? "",
+            email: user?.email ?? null,
+            displayName: user?.displayName ?? null,
+            photoURL: user?.photoURL ?? null,
+            roles: user?.roles ?? []
+        },
+        now: Date.now()
+    };
+}
+
+/**
+ * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
+ */
+export function applyPropertyConditions(
+    property: Property,
+    context: ConditionContext
+): Property {
+    const { conditions } = property;
+    if (!conditions) return property;
+
+    let result = { ...property };
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // FIELD STATE CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    // Evaluate disabled condition
+    if (conditions.disabled) {
+        const isDisabled = evaluateCondition(conditions.disabled, context);
+        if (isDisabled) {
+            result.disabled = {
+                clearOnDisabled: conditions.clearOnDisabled ?? false,
+                disabledMessage: conditions.disabledMessage,
+                hidden: false
+            };
+        }
+    }
+
+    // Evaluate hidden condition
+    if (conditions.hidden) {
+        const isHidden = evaluateCondition(conditions.hidden, context);
+        if (isHidden) {
+            result.disabled = {
+                ...(typeof result.disabled === "object" ? result.disabled : {}),
+                hidden: true,
+                clearOnDisabled: conditions.clearOnDisabled ?? false
+            };
+        }
+    }
+
+    // Evaluate readOnly condition
+    if (conditions.readOnly) {
+        const isReadOnly = evaluateCondition(conditions.readOnly, context);
+        if (isReadOnly) {
+            result.readOnly = true;
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // VALIDATION CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    // Evaluate required condition
+    if (conditions.required !== undefined) {
+        const isRequired = evaluateCondition(conditions.required, context) as boolean;
+        result.validation = {
+            ...result.validation,
+            required: isRequired as boolean | undefined,
+            requiredMessage: conditions.requiredMessage
+        };
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // VALUE CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    // Apply default value for new entities
+    if (context.isNew && conditions.defaultValue !== undefined) {
+        result.defaultValue = evaluateCondition(conditions.defaultValue, context) as Property["defaultValue"];
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ENUM CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    if ("enumValues" in result && result.enumValues && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
+        (result as Record<string, unknown>).enumValues = applyEnumConditions(
+            result.enumValues as EnumValueConfig[],
+            conditions,
+            context
+        );
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // REFERENCE CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    if (result.type === "reference") {
+        if (conditions.referencePath) {
+            (result as ReferenceProperty).path = evaluateCondition(conditions.referencePath, context) as string;
+        }
+        if (conditions.referenceFilter) {
+            (result as ReferenceProperty).forceFilter = evaluateCondition(conditions.referenceFilter, context) as ReferenceProperty["forceFilter"];
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ARRAY CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    if (result.type === "array") {
+        if (conditions.canAddElements !== undefined) {
+            (result as ArrayProperty).canAddElements = evaluateCondition(conditions.canAddElements, context) as boolean;
+        }
+        if (conditions.sortable !== undefined) {
+            (result as ArrayProperty).sortable = evaluateCondition(conditions.sortable, context) as boolean;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Convert an object with numeric keys back to an array.
+ * Firestore stores arrays as {"0": "a", "1": "b"} to avoid nested arrays.
+ */
+function objectToArray(obj: unknown): string[] {
+    if (Array.isArray(obj)) return obj.map(String);
+    if (obj && typeof obj === "object") {
+        const keys = Object.keys(obj);
+        if (keys.length > 0 && keys.every(k => !isNaN(Number(k)))) {
+            return keys
+                .sort((a, b) => Number(a) - Number(b))
+                .map(k => (obj as Record<string, unknown>)[k])
+                .filter((v): v is string => typeof v === "string" || typeof v === "number")
+                .map(String);
+        }
+    }
+    return [];
+}
+
+/**
+ * Apply enum-specific conditions to filter and modify enum values.
+ */
+function applyEnumConditions(
+    enumValues: EnumValueConfig[],
+    conditions: PropertyConditions,
+    context: ConditionContext
+): EnumValueConfig[] {
+    let result = [...enumValues];
+
+    // Apply allowedEnumValues filter
+    if (conditions.allowedEnumValues) {
+        const allowed = evaluateCondition(conditions.allowedEnumValues, context);
+        // Handle both array format and object-with-numeric-keys format (Firestore workaround)
+        const allowedArray = objectToArray(allowed);
+        if (allowedArray.length > 0) {
+            result = result.filter(ev => allowedArray.includes(String(ev.id)));
+        }
+    }
+
+    // Apply excludedEnumValues filter
+    if (conditions.excludedEnumValues) {
+        const excluded = evaluateCondition(conditions.excludedEnumValues, context);
+        // Handle both array format and object-with-numeric-keys format
+        const excludedArray = objectToArray(excluded);
+        if (excludedArray.length > 0) {
+            result = result.filter(ev => !excludedArray.includes(String(ev.id)));
+        }
+    }
+
+    // Apply individual enum conditions
+    if (conditions.enumConditions) {
+        result = result
+            .map(ev => {
+                const evConditions = conditions.enumConditions?.[ev.id];
+                if (!evConditions) return ev;
+
+                // Check hidden condition first
+                if (evConditions.hidden && evaluateCondition(evConditions.hidden, context)) {
+                    return null; // Will be filtered out
+                }
+
+                // Check disabled condition
+                if (evConditions.disabled && evaluateCondition(evConditions.disabled, context)) {
+                    return {
+                        ...ev,
+                        disabled: true
+                    };
+                }
+
+                return ev;
+            })
+            .filter((ev): ev is EnumValueConfig => ev !== null);
+    }
+
+    return result;
+}

package/src/util/dates.ts

@@ -0,0 +1 @@
+export const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";

package/src/util/entities.ts

@@ -0,0 +1,212 @@
+import {
+    DataType,
+    Entity,
+    EntityReference,
+    EntityRelation,
+    EntityStatus,
+    EntityValues,
+    Properties,
+    Property,
+} from "@rebasepro/types";
+import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
+import { mergeDeep } from "./objects";
+
+export function isReadOnly(property: Property): boolean {
+    if (property.readOnly)
+        return true;
+    if (property.type === "date") {
+        if (property.autoValue)
+            return true;
+    }
+    if (property.type === "reference") {
+        return !property.path && !property.Field;
+    }
+    return false;
+}
+
+export function isHidden(property: Property): boolean {
+    return typeof property.disabled === "object" && Boolean(property.disabled.hidden);
+}
+
+export function isPropertyBuilder(property?: Property) {
+    return typeof property?.dynamicProps === "function";
+}
+
+export function getDefaultValuesFor<M extends Record<string, any>>(properties: Properties): Partial<EntityValues<M>> {
+    if (!properties) return {};
+    return Object.entries(properties)
+        .map(([key, property]) => {
+            if (!property) return {};
+            const value = getDefaultValueFor(property);
+            return value === undefined ? {} : { [key]: value };
+        })
+        .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
+}
+
+export function getDefaultValueFor(property?: Property) {
+    if (!property) return undefined;
+    if (isPropertyBuilder(property)) return undefined;
+    if (property.defaultValue || property.defaultValue === null) {
+        return property.defaultValue;
+    } else if (property.type === "map" && property.properties) {
+        const defaultValuesFor = getDefaultValuesFor(property.properties as Properties);
+        if (Object.keys(defaultValuesFor).length === 0) return undefined;
+        return defaultValuesFor;
+    } else {
+        return getDefaultValueFortype(property.type);
+    }
+}
+
+export function getDefaultValueFortype(type: DataType) {
+    if (type === "string") {
+        return null;
+    } else if (type === "number") {
+        return null;
+    } else if (type === "boolean") {
+        return false;
+    } else if (type === "date") {
+        return null;
+    } else if (type === "array") {
+        return [];
+    } else if (type === "map") {
+        return {};
+    } else {
+        return null;
+    }
+}
+
+/**
+ * Update the automatic values in an entity before save
+ * @group Datasource
+ */
+export function updateDateAutoValues<M extends Record<string, any>>({
+    inputValues,
+    properties,
+    status,
+    timestampNowValue
+}:
+    {
+        inputValues: Partial<EntityValues<M>>,
+        properties: Properties,
+        status: EntityStatus,
+        timestampNowValue: unknown
+    }): EntityValues<M> {
+    return traverseValuesProperties(
+        inputValues,
+        properties,
+        (inputValue, property) => {
+            if (property.type === "date") {
+                if (status === "existing" && property.autoValue === "on_update") {
+                    return timestampNowValue;
+                } else if ((status === "new" || status === "copy") &&
+                    (property.autoValue === "on_update" || property.autoValue === "on_create")) {
+                    return timestampNowValue;
+                } else {
+                    return inputValue;
+                }
+            } else {
+                return inputValue;
+            }
+        }
+    ) ?? {} as M;
+}
+
+/**
+ * Add missing required fields, expected in the collection, to the values of an entity
+ * @param values
+ * @param properties
+ * @group Datasource
+ */
+export function sanitizeData<M extends Record<string, any>>
+    (
+        values: EntityValues<M>,
+        properties: Properties
+    ) {
+    const result = values as Record<string, unknown>;
+    Object.entries(properties)
+        .forEach(([key, property]) => {
+            if (values && values[key] !== undefined) result[key] = values[key];
+            else if ((property as Property).validation?.required) result[key] = null;
+        });
+    return result;
+}
+
+export function getReferenceFrom<M extends Record<string, any>>(entity: Entity<M>): EntityReference {
+    if (typeof entity.id !== "string")
+        throw new Error("Only string IDs are supported in references");
+    return new EntityReference({
+        id: entity.id,
+        path: entity.path,
+        datasource: entity.datasource,
+        databaseId: entity.databaseId
+    });
+}
+
+export function getRelationFrom<M extends Record<string, any>>(entity: Entity<M>): EntityRelation {
+    return new EntityRelation(entity.id, entity.path);
+}
+
+export function traverseValuesProperties<M extends Record<string, any>>(
+    inputValues: Partial<EntityValues<M>>,
+    properties: Properties,
+    operation: (value: unknown, property: Property) => unknown
+): EntityValues<M> | undefined {
+    // Handle null/undefined inputValues - use empty object as base for mergeDeep
+    const safeInputValues = inputValues ?? {};
+
+    const updatedValues = Object.entries(properties)
+        .map(([key, property]) => {
+            const inputValue = safeInputValues && (safeInputValues)[key];
+            const updatedValue = traverseValueProperty(inputValue, property as Property, operation);
+            if (updatedValue === null) return null;
+            if (updatedValue === undefined) return undefined;
+            return ({ [key]: updatedValue });
+        })
+        .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
+    // Use mergeDeep to preserve class instances like EntityReference, GeoPoint
+    const result = mergeDeep(safeInputValues, updatedValues);
+    if (!result || Object.keys(result).length === 0) return undefined;
+    return result;
+}
+
+export function traverseValueProperty(inputValue: unknown,
+    property: Property,
+    operation: (value: unknown, property: Property) => unknown): unknown {
+
+    let value;
+    if (property.type === "map" && property.properties) {
+        value = traverseValuesProperties(inputValue as Partial<Record<string, unknown>>, property.properties, operation);
+    } else if (property.type === "array") {
+        const of = property.of;
+        if (of && Array.isArray(inputValue) && !Array.isArray(of)) {
+            value = inputValue.map((e) => traverseValueProperty(e, of, operation));
+        } else if (of && Array.isArray(inputValue) && Array.isArray(of)) {
+            value = inputValue.map((e, i) => {
+                if (i < of.length)
+                    return traverseValueProperty(e, of[i], operation);
+                return null
+            }).filter(Boolean);
+        } else if (property.oneOf && Array.isArray(inputValue)) {
+            const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+            const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_VALUE;
+            value = inputValue.map((e) => {
+                if (e === null) return null;
+                if (typeof e !== "object") return e;
+                const rec = e as Record<string, unknown>;
+                const type = rec[typeField] as string;
+                const childProperty = property.oneOf?.properties[type];
+                if (!type || !childProperty) return e;
+                return {
+                    [typeField]: type,
+                    [valueField]: traverseValueProperty(rec[valueField], childProperty, operation)
+                };
+            });
+        } else {
+            value = inputValue;
+        }
+    } else {
+        value = operation(inputValue, property);
+    }
+
+    return value;
+}