@rebasepro/common 0.7.0 → 0.9.0

package/src/data/buildRebaseData.ts

@@ -1,143 +1,33 @@
 import {
-    DataDriver,
-    RebaseData,
     CollectionAccessor,
-    FindParams,
-    FindResponse,
+    DataDriver,
     Entity,
     EntityValues,
-    FilterValues,
-    WhereFilterOp,
-    WhereFieldValue,
-    WhereFilterOpShort,
+    FindParams,
+    FindResponse,
+    FindResult,
     LogicalCondition,
+    RebaseData,
+    RebaseSdkData,
+    SDKCollectionClient,
+    SDKQueryBuilderInterface,
+    WhereFilterOp,
     WhereValue
 } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 import { QueryBuilder } from "./query_builder";
+import { deserializeFilter } from "./filter-dialect";
 
 /**
- * Convert where-clause filter object to the internal DataDriver FilterValues format.
- *
- * Supports multiple value formats:
- * - PostgREST string: { status: "eq.published", age: "gte.18" }
- * - Equality shorthand: { company_profile_id: null, status: "active", age: 18 }
- * - Tuple syntax: { age: [">=", 18], role: ["in", ["admin", "editor"]] }
- *
- * Internal:  { status: ["==", "published"], age: [">=", 18] }
+ * Convert a flat REST record (e.g. from RestFetchService) to Entity<M> format.
+ * Mirrors the client SDK's rowToEntity conversion.
  */
-function convertWhereToFilter(where?: Record<string, WhereFieldValue>): FilterValues<string> | undefined {
-    if (!where) return undefined;
-
-    const operatorMap: Record<string, WhereFilterOp> = {
-        "eq": "==",
-        "neq": "!=",
-        "gt": ">",
-        "gte": ">=",
-        "lt": "<",
-        "lte": "<=",
-        "in": "in",
-        "nin": "not-in",
-        "not-in": "not-in",
-        "cs": "array-contains",
-        "csa": "array-contains-any",
-        "==": "==",
-"!=": "!=",
-        ">": ">",
-">=": ">=",
-        "<": "<",
-"<=": "<=",
-        "array-contains": "array-contains",
-        "array-contains-any": "array-contains-any"
+function rowToEntity<M extends Record<string, unknown>>(row: Record<string, unknown>, slug: string): Entity<M> {
+    return {
+        id: row.id as string | number,
+        path: slug,
+        values: row as EntityValues<M>
     };
-
-    const filter: FilterValues<string> = {};
-
-    for (const [field, rawValue] of Object.entries(where)) {
-        // Handle null → equality
-        if (rawValue === null) {
-            filter[field] = ["==", null];
-            continue;
-        }
-
-        // Handle boolean → equality
-        if (typeof rawValue === "boolean") {
-            filter[field] = ["==", rawValue];
-            continue;
-        }
-
-        // Handle number → equality
-        if (typeof rawValue === "number") {
-            filter[field] = ["==", rawValue];
-            continue;
-        }
-
-        // Handle tuple or array of tuples
-        if (Array.isArray(rawValue)) {
-            const conditions: [WhereFilterOpShort, unknown][] = Array.isArray(rawValue[0])
-                ? (rawValue as [WhereFilterOpShort, unknown][])
-                : [rawValue as [WhereFilterOpShort, unknown]];
-
-            const mappedConditions: [WhereFilterOp, unknown][] = conditions.map(([rawOp, val]) => {
-                const mappedOp = operatorMap[rawOp] ?? "==";
-                return [mappedOp, val];
-            });
-
-            filter[field] = Array.isArray(rawValue[0]) ? mappedConditions : mappedConditions[0];
-            continue;
-        }
-
-        // Handle PostgREST string format: "op.value"
-        if (typeof rawValue === "string") {
-            const dotIndex = rawValue.indexOf(".");
-            if (dotIndex === -1) {
-                // Plain string equality
-                filter[field] = ["==", rawValue];
-                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());
-            }
-
-            // Parse null string
-            if (value === "null") {
-                value = null;
-            }
-            // Parse boolean strings
-            else if (value === "true") {
-                value = true;
-            } else if (value === "false") {
-                value = false;
-            }
-            // Try to parse numbers
-            else 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];
 }
 
 function createDriverAccessor<M extends Record<string, unknown> = Record<string, unknown>>(
@@ -146,91 +36,108 @@ function createDriverAccessor<M extends Record<string, unknown> = Record<string,
 ): CollectionAccessor<M> {
     const accessor: CollectionAccessor<M> = {
         async find(params?: FindParams): Promise<FindResponse<M>> {
-            const orderParsed = parseOrderBy(params?.orderBy);
-            const entities = await driver.fetchCollection<M>({
-                path: slug,
-                limit: params?.limit,
-                offset: params?.offset,
-                filter: convertWhereToFilter(params?.where),
-                orderBy: orderParsed?.[0],
-                order: orderParsed?.[1],
-                searchString: params?.searchString
-            });
+            // Ensure filters are in canonical [op, value] format even if passed as PostgREST strings
+            const filter = params?.where ? deserializeFilter(params.where as Record<string, unknown>) : undefined;
             const limit = params?.limit ?? 20;
             const offset = params?.offset ?? 0;
+
+            // Use the RestFetchService for include-aware queries when available
+            const fetchService = driver.restFetchService;
+            const rows = (fetchService && params?.include && params.include.length > 0)
+                ? await fetchService.fetchCollectionForRest(
+                    slug,
+                    {
+                        filter,
+                        limit: params?.limit,
+                        offset: params?.offset,
+                        orderBy: params?.orderBy?.[0],
+                        order: params?.orderBy?.[1],
+                        searchString: params?.searchString
+                    },
+                    params.include
+                )
+                : await driver.fetchCollection<M>({
+                    path: slug,
+                    limit: params?.limit,
+                    offset: params?.offset,
+                    filter,
+                    orderBy: params?.orderBy?.[0],
+                    order: params?.orderBy?.[1],
+                    searchString: params?.searchString
+                });
+
+            // Compute real total when count is available
+            let total = rows.length + offset;
+            let hasMore = rows.length >= limit;
+            if (driver.count) {
+                total = await driver.count({ path: slug, filter });
+                hasMore = offset + rows.length < total;
+            }
+
             return {
-                data: entities,
-                meta: {
-                    total: entities.length,
-                    limit,
-                    offset,
-                    hasMore: entities.length >= limit
-                }
+                data: rows.map((row: Record<string, unknown>) => rowToEntity<M>(row, slug)),
+                meta: { total, limit, offset, hasMore }
             };
         },
 
         async findById(id: string | number): Promise<Entity<M> | undefined> {
-            return driver.fetchEntity<M>({ path: slug,
-entityId: id });
+            const row = await driver.fetchOne<M>({ path: slug, id: id });
+            return row ? rowToEntity<M>(row, slug) : undefined;
         },
 
         async create(data: Partial<EntityValues<M>>, id?: string | number): Promise<Entity<M>> {
-            return driver.saveEntity<M>({
+            const row = await driver.save<M>({
                 path: slug,
                 values: data,
-                entityId: id,
+                id: id,
                 status: "new"
             });
+            return rowToEntity<M>(row, slug);
         },
 
         async update(id: string | number, data: Partial<EntityValues<M>>): Promise<Entity<M>> {
-            return driver.saveEntity<M>({
+            const row = await driver.save<M>({
                 path: slug,
                 values: data,
-                entityId: id,
+                id: id,
                 status: "existing"
             });
+            return rowToEntity<M>(row, slug);
         },
 
         async delete(id: string | number): Promise<void> {
-            return driver.deleteEntity({
-                entity: { id,
+            return driver.delete({
+                row: { id,
 path: slug,
 values: {} as Record<string, unknown> }
             });
         },
 
-        deleteAll: driver.deleteAll
-            ? async (): Promise<void> => {
-                return driver.deleteAll!(slug);
-            }
-            : undefined,
-
-        count: driver.countEntities
+        count: driver.count
             ? async (params?: FindParams): Promise<number> => {
-                return driver.countEntities!({
+                const filter = params?.where ? deserializeFilter(params.where as Record<string, unknown>) : undefined;
+                return driver.count!({
                     path: slug,
-                    filter: convertWhereToFilter(params?.where)
+                    filter
                 });
             }
             : 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,
                     offset: params?.offset,
-                    filter: convertWhereToFilter(params?.where),
-                    orderBy: orderParsed?.[0],
-                    order: orderParsed?.[1],
+                    filter: params?.where,
+                    orderBy: params?.orderBy?.[0],
+                    order: params?.orderBy?.[1],
                     searchString: params?.searchString,
                     onUpdate: (entities) => {
                         onUpdate({
-                            data: entities,
+                            data: entities.map((row: Record<string, unknown>) => rowToEntity<M>(row, slug)),
                             meta: {
                                 total: entities.length,
                                 limit,
@@ -243,18 +150,18 @@ values: {} as Record<string, unknown> }
                 });
             } : undefined,
 
-        listenById: driver.listenEntity
+        listenById: driver.listenOne
             ? (id: string | number, onUpdate: (entity: Entity<M> | undefined) => void, onError?: (error: Error) => void) => {
-                return driver.listenEntity!<M>({
+                return driver.listenOne!<M>({
                     path: slug,
-                    entityId: id,
-                    onUpdate: (entity) => onUpdate(entity ?? undefined),
+                    id: id,
+                    onUpdate: (entity) => onUpdate(entity ? rowToEntity<M>(entity, slug) : undefined),
                     onError
                 });
             } : undefined,
 
         // Fluent Query Builder
-        where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOpShort, value?: unknown) {
+        where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOp, value?: unknown) {
             const builder = new QueryBuilder<M>(accessor);
             if (typeof columnOrCondition === "object") {
                 return builder.where(columnOrCondition);
@@ -291,7 +198,7 @@ values: {} as Record<string, unknown> }
  * @example
  * const data = buildRebaseData(driver);
  * await data.products.create({ name: "Camera", price: 299 });
- * const { data: items } = await data.products.find({ where: { status: "eq.published" } });
+ * const { data: items } = await data.products.find({ where: { status: ["==", "published"] } });
  */
 export function buildRebaseData(driver: DataDriver): RebaseData {
     const cache = new Map<string, CollectionAccessor>();
@@ -323,3 +230,260 @@ export function buildRebaseData(driver: DataDriver): RebaseData {
         }
     });
 }
+
+// =============================================================================
+// SDK data — flat rows (symmetric with the frontend SDK client)
+// =============================================================================
+
+/**
+ * Unwrap a Entity into a flat row. `rowToEntity` stores the whole flat row
+ * (id included) under `.values`, so this is just that payload.
+ */
+function entityToRow<M extends Record<string, unknown>>(entity: Entity<M>): M {
+    return entity.values as unknown as M;
+}
+
+/**
+ * Fluent query builder for the flat SDK data layer. Mirrors {@link QueryBuilder}
+ * but resolves to `FindResult<M>` (flat rows) instead of Entity-wrapped
+ * `FindResponse<M>`.
+ */
+class SdkQueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements SDKQueryBuilderInterface<M> {
+    private params: FindParams = { where: {} };
+
+    constructor(private client: SDKCollectionClient<M>) {}
+
+    where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): this;
+    where(logicalCondition: LogicalCondition): this;
+    where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOp, value?: unknown): this {
+        if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
+            this.params.logical = columnOrCondition as LogicalCondition;
+            return this;
+        }
+        if (!this.params.where) this.params.where = {};
+        const column = columnOrCondition as string;
+        const condition: [WhereFilterOp, unknown] = [operator!, value];
+        const existing = this.params.where[column];
+        if (existing === undefined) {
+            this.params.where[column] = condition;
+        } else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) {
+            (this.params.where[column] as [WhereFilterOp, unknown][]).push(condition);
+        } else {
+            let firstCondition: [WhereFilterOp, unknown];
+            if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") {
+                firstCondition = existing as [WhereFilterOp, unknown];
+            } else {
+                firstCondition = ["==", existing];
+            }
+            this.params.where[column] = [firstCondition, condition];
+        }
+        return this;
+    }
+
+    orderBy(column: keyof M & string, direction: "asc" | "desc" = "asc"): this {
+        this.params.orderBy = [column, direction];
+        return this;
+    }
+
+    limit(count: number): this { this.params.limit = count; return this; }
+    offset(count: number): this { this.params.offset = count; return this; }
+    search(searchString: string): this { this.params.searchString = searchString; return this; }
+    include(...relations: string[]): this { this.params.include = relations; return this; }
+
+    async find(): Promise<FindResult<M>> {
+        return this.client.find(this.params);
+    }
+
+    async count(): Promise<number> {
+        return this.client.count ? this.client.count(this.params) : 0;
+    }
+
+    listen(onUpdate: (data: FindResult<M>) => void, onError?: (error: Error) => void): () => void {
+        if (!this.client.listen) {
+            throw new Error("Listen is only available when the driver supports realtime.");
+        }
+        return this.client.listen(this.params, onUpdate, onError);
+    }
+}
+
+/**
+ * Wrap a Entity-shaped {@link CollectionAccessor} into a flat
+ * {@link SDKCollectionClient}. Every returned record is unwrapped to a flat row
+ * so the backend SDK is byte-for-byte the same shape as the frontend client.
+ */
+function toSdkCollectionClient<M extends Record<string, unknown>>(
+    snap: CollectionAccessor<M>
+): SDKCollectionClient<M> {
+    const client: SDKCollectionClient<M> = {
+        async find(params?: FindParams): Promise<FindResult<M>> {
+            const res = await snap.find(params);
+            return { data: res.data.map(entityToRow), meta: res.meta };
+        },
+        async findById(id: string | number): Promise<M | undefined> {
+            const s = await snap.findById(id);
+            return s ? entityToRow(s) : undefined;
+        },
+        async create(data: Partial<M>, id?: string | number): Promise<M> {
+            return entityToRow(await snap.create(data as Partial<EntityValues<M>>, id));
+        },
+        async update(id: string | number, data: Partial<M>): Promise<M> {
+            return entityToRow(await snap.update(id, data as Partial<EntityValues<M>>));
+        },
+        delete(id: string | number): Promise<void> {
+            return snap.delete(id);
+        },
+        count: snap.count ? (params?: FindParams) => snap.count!(params) : undefined,
+        listen: snap.listen
+            ? (params: FindParams | undefined, onUpdate: (r: FindResult<M>) => void, onError?: (e: Error) => void) =>
+                snap.listen!(params, (res) => onUpdate({ data: res.data.map(entityToRow), meta: res.meta }), onError)
+            : undefined,
+        listenById: snap.listenById
+            ? (id: string | number, onUpdate: (r: M | undefined) => void, onError?: (e: Error) => void) =>
+                snap.listenById!(id, (s) => onUpdate(s ? entityToRow(s) : undefined), onError)
+            : undefined,
+        where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOp, value?: unknown) {
+            const builder = new SdkQueryBuilder<M>(client);
+            if (typeof columnOrCondition === "object") {
+                return builder.where(columnOrCondition);
+            }
+            return builder.where(columnOrCondition as keyof M & string, operator!, value as WhereValue<M[keyof M & string]>);
+        },
+        orderBy: (column: keyof M & string, direction?: "asc" | "desc") => new SdkQueryBuilder<M>(client).orderBy(column, direction),
+        limit: (count: number) => new SdkQueryBuilder<M>(client).limit(count),
+        offset: (count: number) => new SdkQueryBuilder<M>(client).offset(count),
+        search: (searchString: string) => new SdkQueryBuilder<M>(client).search(searchString),
+        include: (...relations: string[]) => new SdkQueryBuilder<M>(client).include(...relations)
+    };
+    return client;
+}
+
+/**
+ * Wrap a flat {@link SDKCollectionClient} into a Entity-shaped
+ * {@link CollectionAccessor}. Every returned row is re-wrapped into the
+ * `{ id, path, values }` view-model the admin CMS renders.
+ */
+function toEntityAccessor<M extends Record<string, unknown>>(
+    sdk: SDKCollectionClient<M>,
+    slug: string
+): CollectionAccessor<M> {
+    const accessor: CollectionAccessor<M> = {
+        async find(params?: FindParams): Promise<FindResponse<M>> {
+            const res = await sdk.find(params);
+            return { data: res.data.map((row) => rowToEntity<M>(row, slug)), meta: res.meta };
+        },
+        async findById(id: string | number): Promise<Entity<M> | undefined> {
+            const row = await sdk.findById(id);
+            return row ? rowToEntity<M>(row, slug) : undefined;
+        },
+        async create(data: Partial<EntityValues<M>>, id?: string | number): Promise<Entity<M>> {
+            return rowToEntity<M>(await sdk.create(data as Partial<M>, id), slug);
+        },
+        async update(id: string | number, data: Partial<EntityValues<M>>): Promise<Entity<M>> {
+            const row = await sdk.update(id, data as Partial<M>);
+            if (!row) throw new Error(`Update returned no data for id ${id}`);
+            return rowToEntity<M>(row, slug);
+        },
+        delete(id: string | number): Promise<void> {
+            return sdk.delete(id);
+        },
+        count: sdk.count ? (params?: FindParams) => sdk.count!(params) : undefined,
+        listen: sdk.listen
+            ? (params: FindParams | undefined, onUpdate: (r: FindResponse<M>) => void, onError?: (e: Error) => void) =>
+                sdk.listen!(params, (res) => onUpdate({ data: res.data.map((row) => rowToEntity<M>(row, slug)), meta: res.meta }), onError)
+            : undefined,
+        listenById: sdk.listenById
+            ? (id: string | number, onUpdate: (s: Entity<M> | undefined) => void, onError?: (e: Error) => void) =>
+                sdk.listenById!(id, (row) => onUpdate(row ? rowToEntity<M>(row, slug) : undefined), onError)
+            : undefined,
+        where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOp, value?: unknown) {
+            const builder = new QueryBuilder<M>(accessor);
+            if (typeof columnOrCondition === "object") {
+                return builder.where(columnOrCondition);
+            }
+            return builder.where(columnOrCondition as keyof M & string, operator!, value as WhereValue<M[keyof M & string]>);
+        },
+        orderBy: (column: keyof M & string, direction?: "asc" | "desc") => new QueryBuilder<M>(accessor).orderBy(column, direction),
+        limit: (count: number) => new QueryBuilder<M>(accessor).limit(count),
+        offset: (count: number) => new QueryBuilder<M>(accessor).offset(count),
+        search: (searchString: string) => new QueryBuilder<M>(accessor).search(searchString),
+        include: (...relations: string[]) => new QueryBuilder<M>(accessor).include(...relations)
+    };
+    return accessor;
+}
+
+/**
+ * Wrap a flat {@link RebaseSdkData} into a Entity-shaped {@link RebaseData}.
+ *
+ * This is the **CMS boundary**: the SDK client (`client.data`) returns flat
+ * rows, but the admin renders the `Entity` view-model (`entity.values.*`).
+ * `core/Rebase.tsx` wraps `client.data` through this before handing it to the
+ * CMS `RebaseDataContext` — without it the admin renders rows with only their
+ * `id`.
+ */
+export function wrapAsEntityData(sdkData: RebaseSdkData): RebaseData {
+    const cache = new Map<string, CollectionAccessor>();
+
+    function getAccessor(slug: string): CollectionAccessor {
+        let accessor = cache.get(slug);
+        if (!accessor) {
+            accessor = toEntityAccessor(sdkData.collection(slug), 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;
+            if (typeof prop === "symbol") return undefined;
+            if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return undefined;
+            return getAccessor(toSnakeCase(prop));
+        }
+    });
+}
+
+/**
+ * Wrap a Entity-shaped {@link RebaseData} into a flat {@link RebaseSdkData}.
+ *
+ * Every collection accessor is adapted to return flat rows. Use this to derive
+ * the flat SDK data layer (`context.data`) from an existing Entity data layer
+ * — e.g. the admin routes its Entity data via `useData()` and exposes the
+ * same routing as flat `context.data` for callbacks by wrapping it here.
+ */
+export function wrapAsSdkData(entityData: RebaseData): RebaseSdkData {
+    const cache = new Map<string, SDKCollectionClient>();
+
+    function getAccessor(slug: string): SDKCollectionClient {
+        let accessor = cache.get(slug);
+        if (!accessor) {
+            accessor = toSdkCollectionClient(entityData.collection(slug));
+            cache.set(slug, accessor);
+        }
+        return accessor;
+    }
+
+    const target = { collection: getAccessor } as RebaseSdkData;
+
+    return new Proxy(target, {
+        get(_target, prop: string | symbol) {
+            if (prop === "collection") return getAccessor;
+            if (typeof prop === "symbol") return undefined;
+            if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return undefined;
+            return getAccessor(toSnakeCase(prop));
+        }
+    });
+}
+
+/**
+ * Build a flat {@link RebaseSdkData} from a `DataDriver`.
+ *
+ * This is the developer-facing SDK data layer used by backend framework
+ * callbacks & scripts (`context.data` / `rebase.data`). It returns flat rows —
+ * identical in shape to the frontend SDK client — so the API is symmetric
+ * across front and back. The admin CMS uses {@link buildRebaseData} (Entity).
+ */
+export function buildSdkData(driver: DataDriver): RebaseSdkData {
+    return wrapAsSdkData(buildRebaseData(driver));
+}