@rebasepro/common 0.0.1-canary.2 → 0.0.1-canary.4d4fb3e

package/src/data/buildRebaseData.ts

@@ -0,0 +1,221 @@
+import {
+    DataDriver,
+    RebaseData,
+    CollectionAccessor,
+    FindParams,
+    FindResponse,
+    Entity,
+    EntityValues,
+    FilterValues,
+    WhereFilterOp
+} from "@rebasepro/types";
+
+/**
+ * Convert PostgREST-style filter object to the internal DataDriver FilterValues format.
+ *
+ * PostgREST: { status: "eq.published", age: "gte.18" }
+ * Internal:  { status: ["==", "published"], age: [">=", 18] }
+ */
+function convertWhereToFilter(where?: Record<string, string>): FilterValues<string> | undefined {
+    if (!where) return undefined;
+
+    const operatorMap: Record<string, WhereFilterOp> = {
+        "eq": "==",
+        "neq": "!=",
+        "gt": ">",
+        "gte": ">=",
+        "lt": "<",
+        "lte": "<=",
+        "in": "in",
+        "nin": "not-in",
+        "cs": "array-contains",
+        "csa": "array-contains-any",
+    };
+
+    const filter: FilterValues<string> = {};
+
+    for (const [field, rawValue] of Object.entries(where)) {
+        const dotIndex = rawValue.indexOf(".");
+        if (dotIndex === -1) continue;
+
+        const op = rawValue.substring(0, dotIndex);
+        let value: unknown = rawValue.substring(dotIndex + 1);
+
+        // Parse list values like "(admin,editor)"
+        if (typeof value === "string" && value.startsWith("(") && value.endsWith(")")) {
+            value = value.slice(1, -1).split(",").map((v: string) => v.trim());
+        }
+
+        // Try to parse numbers
+        if (typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "") {
+            value = Number(value);
+        }
+
+        const mappedOp = operatorMap[op];
+        if (mappedOp) {
+            filter[field] = [mappedOp, value];
+        }
+    }
+
+    return Object.keys(filter).length > 0 ? filter : undefined;
+}
+
+/**
+ * Parse an orderBy string like "created_at:desc" into [field, direction].
+ */
+function parseOrderBy(orderBy?: string): [string, "asc" | "desc"] | undefined {
+    if (!orderBy) return undefined;
+    const parts = orderBy.split(":");
+    const field = parts[0];
+    const direction = (parts[1] as "asc" | "desc") || "asc";
+    return [field, direction];
+}
+
+/**
+ * Create a CollectionAccessor that delegates to a DataDriver for a given collection slug.
+ */
+function createDriverAccessor<M extends Record<string, unknown> = Record<string, unknown>>(
+    driver: DataDriver,
+    slug: string
+): CollectionAccessor<M> {
+    return {
+        async find(params?: FindParams): Promise<FindResponse<M>> {
+            const orderParsed = parseOrderBy(params?.orderBy);
+            const entities = await driver.fetchCollection<M>({
+                path: slug,
+                limit: params?.limit,
+                startAfter: params?.offset,
+                filter: convertWhereToFilter(params?.where),
+                orderBy: orderParsed?.[0],
+                order: orderParsed?.[1],
+                searchString: params?.searchString,
+            });
+            const limit = params?.limit ?? 20;
+            const offset = params?.offset ?? 0;
+            return {
+                data: entities,
+                meta: {
+                    total: entities.length,
+                    limit,
+                    offset,
+                    hasMore: entities.length >= limit
+                }
+            };
+        },
+
+        async findById(id: string | number): Promise<Entity<M> | undefined> {
+            return driver.fetchEntity<M>({ path: slug, entityId: id });
+        },
+
+        async create(data: Partial<EntityValues<M>>, id?: string | number): Promise<Entity<M>> {
+            return driver.saveEntity<M>({
+                path: slug,
+                values: data,
+                entityId: id,
+                status: "new"
+            });
+        },
+
+        async update(id: string | number, data: Partial<EntityValues<M>>): Promise<Entity<M>> {
+            return driver.saveEntity<M>({
+                path: slug,
+                values: data,
+                entityId: id,
+                status: "existing"
+            });
+        },
+
+        async delete(id: string | number): Promise<void> {
+            return driver.deleteEntity({
+                entity: { id, path: slug, values: {} as Record<string, unknown> }
+            });
+        },
+
+        count: driver.countEntities
+            ? async (params?: FindParams): Promise<number> => {
+                return driver.countEntities!({
+                    path: slug,
+                    filter: convertWhereToFilter(params?.where),
+                });
+            }
+            : undefined,
+
+        listen: driver.listenCollection
+            ? (params: FindParams | undefined, onUpdate: (response: FindResponse<M>) => void, onError?: (error: Error) => void) => {
+                const orderParsed = parseOrderBy(params?.orderBy);
+                const limit = params?.limit ?? 20;
+                const offset = params?.offset ?? 0;
+                return driver.listenCollection!<M>({
+                    path: slug,
+                    limit: params?.limit,
+                    startAfter: params?.offset,
+                    filter: convertWhereToFilter(params?.where),
+                    orderBy: orderParsed?.[0],
+                    order: orderParsed?.[1],
+                    searchString: params?.searchString,
+                    onUpdate: (entities) => {
+                        onUpdate({
+                            data: entities,
+                            meta: {
+                                total: entities.length,
+                                limit,
+                                offset,
+                                hasMore: entities.length >= limit
+                            }
+                        });
+                    },
+                    onError
+                });
+            } : undefined,
+
+        listenById: driver.listenEntity
+            ? (id: string | number, onUpdate: (entity: Entity<M> | undefined) => void, onError?: (error: Error) => void) => {
+                return driver.listenEntity!<M>({
+                    path: slug,
+                    entityId: id,
+                    onUpdate: (entity) => onUpdate(entity ?? undefined),
+                    onError
+                });
+            } : undefined
+    };
+}
+
+/**
+ * Build a `RebaseData` object from a `DataDriver` using JavaScript Proxy.
+ *
+ * This is the key bridge: any property access like `data.products` returns
+ * a `CollectionAccessor` backed by the underlying DataDriver, without
+ * needing per-collection code generation.
+ *
+ * @example
+ * const data = buildRebaseData(driver);
+ * await data.products.create({ name: "Camera", price: 299 });
+ * const { data: items } = await data.products.find({ where: { status: "eq.published" } });
+ */
+export function buildRebaseData(driver: DataDriver): RebaseData {
+    const cache = new Map<string, CollectionAccessor>();
+
+    function getAccessor(slug: string): CollectionAccessor {
+        let accessor = cache.get(slug);
+        if (!accessor) {
+            accessor = createDriverAccessor(driver, slug);
+            cache.set(slug, accessor);
+        }
+        return accessor;
+    }
+
+    const target = {
+        collection: getAccessor
+    } as RebaseData;
+
+    return new Proxy(target, {
+        get(_target, prop: string | symbol) {
+            if (prop === "collection") return getAccessor;
+            // Ignore Symbol properties (e.g. Symbol.toPrimitive, Symbol.iterator)
+            if (typeof prop === "symbol") return undefined;
+            // Ignore internal JS properties
+            if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return undefined;
+            return getAccessor(prop);
+        }
+    });
+}

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./util";
 export * from "./collections";
+export * from "./data/buildRebaseData";

package/src/types/json-logic-js.d.ts

@@ -0,0 +1,8 @@
+declare module "json-logic-js" {
+    interface JsonLogic {
+        apply(logic: unknown, data?: unknown): unknown;
+        add_operation<T extends any[]>(name: string, fn: (...args: T) => unknown): void;
+    }
+    const jsonLogic: JsonLogic;
+    export default jsonLogic;
+}

package/src/util/builders.ts

@@ -11,12 +11,12 @@ import {
     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
@@ -24,7 +24,7 @@ import {
  * @group Builder
  */
 export function buildCollection<
-    M extends Record<string, any> = any,
+    M extends Record<string, unknown> = Record<string, unknown>,
     USER extends User = User>
     (
         collection: EntityCollection<M, USER>
@@ -50,7 +50,7 @@ export function buildProperty<T, P extends Property = Property>(
     P extends ArrayProperty ? ArrayProperty :
     P extends MapProperty ? MapProperty : never {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return property as any;
+    return property as unknown as ReturnType<typeof buildProperty<T, P>>;
 }
 
 /**
@@ -59,7 +59,7 @@ export function buildProperty<T, P extends Property = Property>(
  * @param properties
  * @group Builder
  */
-export function buildProperties<M extends Record<string, any>>(
+export function buildProperties<M extends Record<string, unknown>>(
     properties: Properties
 ): Properties {
     return properties;
@@ -71,7 +71,7 @@ export function buildProperties<M extends Record<string, any>>(
  * @param propertiesOrBuilder
  * @group Builder
  */
-export function buildPropertiesOrBuilder<M extends Record<string, any>>(
+export function buildPropertiesOrBuilder<M extends Record<string, unknown>>(
     propertiesOrBuilder: Properties
 ): Properties {
     return propertiesOrBuilder;
@@ -107,7 +107,7 @@ export function buildEnumValueConfig(
  * @param callbacks
  * @group Builder
  */
-export function buildEntityCallbacks<M extends Record<string, any> = any>(
+export function buildEntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>>(
     callbacks: EntityCallbacks<M>
 ): EntityCallbacks<M> {
     return callbacks;
@@ -119,20 +119,10 @@ export function buildEntityCallbacks<M extends Record<string, any> = any>(
  * @param additionalFieldDelegate
  * @group Builder
  */
-export function buildAdditionalFieldDelegate<M extends Record<string, any>, USER extends User = User>(
+export function buildAdditionalFieldDelegate<M extends Record<string, unknown>, 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

@@ -1,5 +1,4 @@
 import { EntityCallbacks, Properties } from "@rebasepro/types";
-import { mergeDeep } from "./objects";
 
 /**
  * Helper function to recursively check if there are any callbacks in the properties.
@@ -33,13 +32,13 @@ async function processProperties(
 ): Promise<Record<string, unknown>> {
     if (!values || typeof values !== "object") return values;
 
-    let result = { ...values };
+    const result = { ...values };
 
     for (const [key, property] of Object.entries(properties)) {
         if (result[key] === undefined) continue;
 
         let currentValue = result[key];
-        let previousValue = previousValues?.[key];
+        const previousValue = previousValues?.[key];
 
         // 1. Array Property
         if (property.type === "array" && Array.isArray(currentValue)) {
@@ -66,7 +65,7 @@ async function processProperties(
                 ...(propsContext as Record<string, unknown>),
                 value: currentValue,
                 previousValue
-            } as any));
+            } as never));
             if (cbRes !== undefined) {
                 currentValue = cbRes;
             }

package/src/util/collections.ts

@@ -7,7 +7,7 @@ import {
 } from "@rebasepro/types";
 import { isPropertyBuilder } from "./entities";
 
-export function sortProperties<M extends Record<string, any>>(properties: Properties, propertiesOrder?: string[]): Properties {
+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
@@ -54,7 +54,7 @@ export function sortProperties<M extends Record<string, any>>(properties: Proper
                     return ({ [key]: property });
                 }
             })
-            .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as Properties;
+            .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
@@ -72,7 +72,7 @@ export function sortProperties<M extends Record<string, any>>(properties: Proper
                     return ({ [key]: property });
                 }
             })
-            .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as Properties;
+            .reduce((a: Properties, b: Properties) => ({ ...a, ...b }), {}) as Properties;
 
         return { ...orderedResult, ...missingProperties };
     } catch (e) {
@@ -110,7 +110,7 @@ export function getLocalChangesBackup(collection: EntityCollection) {
  * 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>[] {
+export function getPrimaryKeys<M extends Record<string, unknown>>(collection: EntityCollection<M>): Extract<keyof M, string>[] {
     const properties = collection.properties;
     if (!properties) {
         return ["id"] as Extract<keyof M, string>[];

package/src/util/conditions.ts

@@ -152,7 +152,7 @@ export function buildConditionContext(params: {
             email: user?.email ?? null,
             displayName: user?.displayName ?? null,
             photoURL: user?.photoURL ?? null,
-            roles: user?.roles ?? []
+            roles: (user?.roles ?? []).map((r: unknown) => typeof r === "string" ? r : (r as { id: string }).id)
         },
         now: Date.now()
     };
@@ -233,9 +233,9 @@ export function applyPropertyConditions(
     // 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[],
+    if ("enum" in result && result.enum && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
+        (result as Record<string, unknown>).enum = applyEnumConditions(
+            result.enum as EnumValueConfig[],
             conditions,
             context
         );

package/src/util/entities.ts

@@ -9,7 +9,7 @@ import {
     Property,
 } from "@rebasepro/types";
 import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
-import { mergeDeep } from "./objects";
+import { mergeDeep } from "@rebasepro/utils";
 
 export function isReadOnly(property: Property): boolean {
     if (property.readOnly)
@@ -19,7 +19,7 @@ export function isReadOnly(property: Property): boolean {
             return true;
     }
     if (property.type === "reference") {
-        return !property.path && !property.Field;
+        return !property.path && !("Field" in property && property.Field);
     }
     return false;
 }
@@ -32,7 +32,7 @@ export function isPropertyBuilder(property?: Property) {
     return typeof property?.dynamicProps === "function";
 }
 
-export function getDefaultValuesFor<M extends Record<string, any>>(properties: Properties): Partial<EntityValues<M>> {
+export function getDefaultValuesFor<M extends Record<string, unknown>>(properties: Properties): Partial<EntityValues<M>> {
     if (!properties) return {};
     return Object.entries(properties)
         .map(([key, property]) => {
@@ -77,9 +77,9 @@ export function getDefaultValueFortype(type: DataType) {
 
 /**
  * Update the automatic values in an entity before save
- * @group Datasource
+ * @group Driver
  */
-export function updateDateAutoValues<M extends Record<string, any>>({
+export function updateDateAutoValues<M extends Record<string, unknown>>({
     inputValues,
     properties,
     status,
@@ -115,9 +115,9 @@ export function updateDateAutoValues<M extends Record<string, any>>({
  * Add missing required fields, expected in the collection, to the values of an entity
  * @param values
  * @param properties
- * @group Datasource
+ * @group Driver
  */
-export function sanitizeData<M extends Record<string, any>>
+export function sanitizeData<M extends Record<string, unknown>>
     (
         values: EntityValues<M>,
         properties: Properties
@@ -131,22 +131,47 @@ export function sanitizeData<M extends Record<string, any>>
     return result;
 }
 
-export function getReferenceFrom<M extends Record<string, any>>(entity: Entity<M>): EntityReference {
+export function getReferenceFrom<M extends Record<string, unknown>>(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,
+        driver: entity.driver,
         databaseId: entity.databaseId
     });
 }
 
-export function getRelationFrom<M extends Record<string, any>>(entity: Entity<M>): EntityRelation {
-    return new EntityRelation(entity.id, entity.path);
+export function getRelationFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityRelation {
+    return new EntityRelation(entity.id, entity.path, entity);
 }
 
-export function traverseValuesProperties<M extends Record<string, any>>(
+/**
+ * Normalize a value into a proper EntityRelation instance.
+ * Handles EntityRelation class instances, and plain objects
+ * with `__type === "relation"` or an `isEntityRelation()` method.
+ *
+ * Returns null if the value cannot be coerced.
+ */
+export function normalizeToEntityRelation(value: unknown): EntityRelation | null {
+    if (value instanceof EntityRelation) return value;
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+
+    const obj = value as Record<string, unknown>;
+    const isRelationLike =
+        obj.__type === "relation" ||
+        (typeof obj.isEntityRelation === "function" && (obj.isEntityRelation as () => boolean)());
+
+    if (!isRelationLike) return null;
+
+    return new EntityRelation(
+        obj.id as string | number,
+        obj.path as string,
+        obj.data as Entity | undefined
+    );
+}
+
+export function traverseValuesProperties<M extends Record<string, unknown>>(
     inputValues: Partial<EntityValues<M>>,
     properties: Properties,
     operation: (value: unknown, property: Property) => unknown

package/src/util/index.ts

@@ -1,26 +1,16 @@
 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";
+export * from "./navigation_utils";

package/src/util/navigation_from_path.ts

@@ -1,13 +1,14 @@
-import { EntityCollection, EntityCustomView } from "@rebasepro/types";
+import { EntityCollection } from "@rebasepro/types";
+type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = { key: string; [key: string]: unknown };
 import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
 import { getSubcollections } from "./resolutions";
 
-export type NavigationViewInternal<M extends Record<string, any> = any> =
+export type NavigationViewInternal<M extends Record<string, unknown> = Record<string, unknown>> =
     | NavigationViewEntityInternal<M>
     | NavigationViewCollectionInternal<M>
     | NavigationViewEntityCustomInternal<M>;
 
-export interface NavigationViewEntityInternal<M extends Record<string, any>> {
+export interface NavigationViewEntityInternal<M extends Record<string, unknown>> {
     type: "entity";
     entityId: string | number;
     slug: string;
@@ -15,7 +16,7 @@ export interface NavigationViewEntityInternal<M extends Record<string, any>> {
     parentCollection: EntityCollection<M>;
 }
 
-export interface NavigationViewCollectionInternal<M extends Record<string, any>> {
+export interface NavigationViewCollectionInternal<M extends Record<string, unknown>> {
     type: "collection";
     id: string;
     slug: string;
@@ -23,7 +24,7 @@ export interface NavigationViewCollectionInternal<M extends Record<string, any>>
     collection: EntityCollection<M>;
 }
 
-export interface NavigationViewEntityCustomInternal<M extends Record<string, any>> {
+export interface NavigationViewEntityCustomInternal<M extends Record<string, unknown>> {
     type: "custom_view";
     slug: string;
     path: string;
@@ -84,8 +85,8 @@ export function getNavigationEntriesFromPath(props: {
                     const entityViews = collection.entityViews;
                     const customView = entityViews && entityViews
                         .map((entry) => resolveEntityView(entry, props.contextEntityViews))
-                        .filter(Boolean)
-                        .find((entry) => entry!.key === newPath);
+                        .filter((v): v is EntityCustomView => v != null)
+                        .find((entry) => entry.key === newPath);
                     const subcollections = getSubcollections(collection);
                     if (customView) {
                         result.push({

package/src/util/navigation_utils.ts

@@ -1,4 +1,5 @@
-import { EntityCollection, CMSUrlController, SideEntityController } from "@rebasepro/types";
+import { EntityCollection } from "@rebasepro/types";
+
 import { getSubcollections } from "./resolutions";
 
 export function removeInitialAndTrailingSlashes(s: string): string {
@@ -66,7 +67,7 @@ export function resolveCollectionPathIds(path: string, allCollections: EntityCol
                 match: matchString
             } = potentialMatches[0];
 
-            resolvedPathParts.push(foundCollection.dbPath); // Use the defined path
+            resolvedPathParts.push(foundCollection.slug); // Use the defined path
             remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
 
             // Check if we are at the end of the path
@@ -141,7 +142,7 @@ export function getCollectionBySlugWithin(slugOrPath: string, collections: Entit
 
             if (subpathCombination === slugOrPath) {
                 result = navigationEntry;
-            } else if (navigationEntry.subcollections) {
+            } else if (getSubcollections(navigationEntry).length > 0) {
                 const newPath = slugOrPath.replace(subpathCombination, "").split("/").slice(2).join("/");
                 if (newPath.length > 0)
                     result = getCollectionBySlugWithin(newPath, getSubcollections(navigationEntry));
@@ -166,57 +167,4 @@ export function getCollectionPathsCombinations(subpaths: string[]): string[] {
         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);
-    }
-
 }

package/src/util/parent_references_from_path.ts

@@ -40,7 +40,7 @@ export function getParentReferencesFromPath(props: {
                     if (!collection) {
                         throw Error("collection not found resolving path: " + collection);
                     }
-                    if (collection.subcollections) {
+                    if (getSubcollections(collection).length > 0) {
                         result.push(...getParentReferencesFromPath({
                             path: newPath,
                             collections: getSubcollections(collection),