@rebasepro/common 0.17.3 → 0.18.1

package/src/util/callbacks.ts

@@ -1,122 +0,0 @@
-import { CollectionCallbacks, Properties, RebaseCallContext } from "@rebasepro/types";
-
-/**
- * Context passed to entity lifecycle callbacks.
- * @group Models
- */
-export type EntityCallbackContext = RebaseCallContext;
-
-
-/**
- * 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;
-
-    const result = { ...values };
-
-    for (const [key, property] of Object.entries(properties)) {
-        if (result[key] === undefined) continue;
-
-        let currentValue = result[key];
-        const 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]) {
-
-            const cbRes = await Promise.resolve(property.callbacks[callbackName]({
-                ...(propsContext as Record<string, unknown>),
-                value: currentValue,
-                previousValue
-            } as never));
-            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 CollectionCallbacks object recursively.
- */
-export const buildPropertyCallbacks = (properties: Properties): CollectionCallbacks | undefined => {
-    if (!properties) return undefined;
-
-    const propertyCallbacks: CollectionCallbacks = {};
-
-    if (hasPropertyCallbacks(properties, "afterRead")) {
-        propertyCallbacks.afterRead = async (props) => {
-            const row = props.row;
-            const processedValues = await processProperties(
-                properties,
-                row,
-                row,
-                props as unknown,
-                "afterRead"
-            );
-            return { ...props.row, ...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;
-};

package/src/util/collections.ts

@@ -1,117 +0,0 @@
-import {
-    CollectionConfig,
-    Properties,
-    Property
-} from "@rebasepro/types";
-import { isPropertyBuilder } from "./entities";
-
-export function sortProperties<M extends Record<string, unknown>>(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: Properties, b: Properties) => ({ ...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: Properties, b: Properties) => ({ ...a,
-...b }), {}) as Properties;
-
-        return { ...orderedResult,
-...missingProperties };
-    } catch (e) {
-        console.error("Error sorting properties", e);
-        return properties;
-    }
-}
-
-/**
- * A copy of `collections` ordered by slug.
- *
- * Every generator that turns collections into a file is order-dependent, and
- * every one of them is compared against its own output — `rebase doctor`
- * regenerates in memory and diffs, `generate-sdk && git diff --exit-code` gates
- * CI. While only the *writers* sorted, a project whose `readdirSync` order
- * differed from its slug order was reported permanently out of date, and the
- * fix the message printed rewrote the file in the order it was already in. The
- * generators sort themselves now, so no caller can get this wrong.
- *
- * A slug-less collection is left to the generator's own validation, which names
- * the offending collection; sorting must not throw first.
- */
-export function sortCollectionsBySlug<C extends { slug?: string }>(collections: readonly C[]): C[] {
-    return [...collections].sort((a, b) => (a.slug ?? "").localeCompare(b.slug ?? ""));
-}
-
-export function getPrimaryKeys<M extends Record<string, unknown>>(collection: CollectionConfig<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

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

package/src/util/conditions.ts

@@ -1,168 +0,0 @@
-import jsonLogic from "json-logic-js";
-import {
-    ArrayProperty,
-    AuthState,
-    ConditionContext,
-    ConditionRule,
-    EnumValueConfig,
-    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 condition against the given context.
- *
- * A condition may be stated as a literal instead of a rule — `hidden: true`
- * rather than `hidden: { "==": [1, 1] }` — and a literal is already its own
- * answer, so it is returned rather than handed to the evaluator.
- */
-export function evaluateCondition(rule: ConditionRule, context: ConditionContext): unknown {
-    if (typeof rule === "boolean") return rule;
-    // 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: AuthState;
-}): 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 ?? []).map((r: unknown) => typeof r === "string" ? r : (r as { id: string }).id)
-        },
-        now: Date.now()
-    };
-}
-
-/**
- * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
- */

package/src/util/email.ts

@@ -1,32 +0,0 @@
-/**
- * Email normalization — one implementation, because the database enforces it.
- *
- * `ensureAuthTablesExist` puts a `UNIQUE INDEX ON users (lower(email))` on the
- * auth table. That index decides what "the same address" means, and it does not
- * trim: to Postgres, `' foo@bar.com'` and `'foo@bar.com'` are two addresses and
- * both may exist. So every write that reaches the column has to agree with
- * every read, exactly, or the two disagree in the one direction that matters —
- * a row that exists and cannot be found.
- *
- * That is not hypothetical. The lookup path trimmed and the admin create paths
- * did not, so a user created through `POST /api/data/users` or
- * `POST /api/auth/admin/users` with a stray space was stored untrimmed,
- * survived the unique index alongside the real address, and was unreachable by
- * login forever after. The HTTP auth routes were unaffected only because Zod's
- * `.email()` happens to reject surrounding whitespace — a guard on a different
- * layer, for a different reason, that the admin paths do not sit behind.
- *
- * It lives in `common` because `server`, `server-postgres` and `server-mongo`
- * all write this column and must agree exactly, and `common` is the only
- * package all three already depend on.
- */
-
-/**
- * Canonical form of an email address: trimmed, lower-cased.
- *
- * Non-strings pass through untouched, so this is safe to apply to a value out
- * of a partial update payload whose type is not known yet.
- */
-export function normalizeEmail<T>(email: T): T | string {
-    return typeof email === "string" ? email.trim().toLowerCase() : email;
-}