@rebasepro/client 0.0.1-canary.4d4fb3e

package/src/collection.ts

@@ -0,0 +1,198 @@
+import { Transport, FindParams, FindResponse, buildQueryString } from "./transport";
+import { RebaseWebSocketClient } from "./websocket";
+import { Entity, FilterValues, WhereFilterOp, CollectionAccessor } from "@rebasepro/types";
+
+import { FilterOperator, QueryBuilder } from "./query_builder";
+
+function parseWhereFilter(where?: Record<string, string>): FilterValues<any> | undefined {
+    if (!where) return undefined;
+    const filters: Record<string, [WhereFilterOp, unknown]> = {};
+    for (const [key, value] of Object.entries(where)) {
+        const dotIndex = value.indexOf(".");
+        if (dotIndex > 0) {
+            const opStr = value.substring(0, dotIndex);
+            const valStr = value.substring(dotIndex + 1);
+            let op: WhereFilterOp = "==";
+            let val: any = valStr;
+            
+            switch (opStr) {
+                case "eq": op = "=="; break;
+                case "neq": op = "!="; break;
+                case "gt": op = ">"; break;
+                case "gte": op = ">="; break;
+                case "lt": op = "<"; break;
+                case "lte": op = "<="; break;
+                case "in": 
+                    op = "in";
+                    val = valStr.startsWith("(") && valStr.endsWith(")") 
+                        ? valStr.slice(1, -1).split(",").map(v => v.trim())
+                        : valStr.split(",");
+                    break;
+                case "nin": 
+                    op = "not-in";
+                    val = valStr.startsWith("(") && valStr.endsWith(")") 
+                        ? valStr.slice(1, -1).split(",").map(v => v.trim())
+                        : valStr.split(",");
+                    break;
+                case "cs": op = "array-contains"; break;
+                case "csa": 
+                    op = "array-contains-any";
+                    val = valStr.startsWith("(") && valStr.endsWith(")") 
+                        ? valStr.slice(1, -1).split(",").map(v => v.trim())
+                        : valStr.split(",");
+                    break;
+                default: op = "=="; val = value;
+            }
+            // Simple type inference for parsing from URL-like strings
+            if (val === "true") val = true;
+            else if (val === "false") val = false;
+            else if (val === "null") val = null;
+            else if (typeof val === "string" && /^[0-9]+(\.[0-9]+)?$/.test(val)) val = Number(val);
+            
+            filters[key] = [op, val];
+        } else {
+            filters[key] = ["==", value];
+        }
+    }
+    return filters;
+}
+
+/**
+ * Wrap a flat row (returned by the REST API as `{ id, ...fields }`) into
+ * a proper `Entity<M>` structure expected by the core framework.
+ * The `id` is kept inside `values` as well, since collection properties
+ * may define an `isId` field that the form binds to `formex.values`.
+ */
+function rowToEntity<M extends Record<string, any>>(row: Record<string, any>, slug: string): Entity<M> {
+    return {
+        id: row.id,
+        path: slug,
+        values: row as M
+    };
+}
+
+/**
+ * CollectionClient extends `CollectionAccessor` from `@rebasepro/types` so that
+ * `client.data` can be passed directly to the core Rebase component.
+ *
+ * Additionally it exposes fluent query builder methods like `.where()`, `.orderBy()`.
+ */
+export interface CollectionClient<M extends Record<string, any> = any> extends CollectionAccessor<M> {
+    // Fluent Query Builder
+    where(column: keyof M & string, operator: FilterOperator, value: any): QueryBuilder<M>;
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilder<M>;
+    limit(count: number): QueryBuilder<M>;
+    offset(count: number): QueryBuilder<M>;
+    search(searchString: string): QueryBuilder<M>;
+    include(...relations: string[]): QueryBuilder<M>;
+}
+
+export function createCollectionClient<M extends Record<string, any> = any>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M> {
+    const basePath = `/data/${slug}`;
+
+    return {
+        async find(params?: FindParams) {
+            const qs = buildQueryString(params);
+            const raw = await transport.request<{ data: Record<string, any>[]; meta: any }>(basePath + qs, { method: "GET" });
+            return {
+                data: (raw.data || []).map((row: Record<string, any>) => rowToEntity<M>(row, slug)),
+                meta: raw.meta
+            };
+        },
+
+        async findById(id: string | number) {
+            const raw = await transport.request<Record<string, any>>(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
+            if (!raw) return undefined;
+            return rowToEntity<M>(raw, slug);
+        },
+
+        async create(data: Partial<M>, id?: string | number) {
+            const body: Record<string, unknown> = { ...data };
+            if (id !== undefined) {
+                body.id = id;
+            }
+            const raw = await transport.request<Record<string, any>>(basePath, {
+                method: "POST",
+                body: JSON.stringify(body),
+            });
+            return rowToEntity<M>(raw, slug);
+        },
+
+        async update(id: string | number, data: Partial<M>) {
+            const raw = await transport.request<Record<string, any>>(`${basePath}/${encodeURIComponent(String(id))}`, {
+                method: "PUT",
+                body: JSON.stringify(data),
+            });
+            return rowToEntity<M>(raw, slug);
+        },
+
+        async delete(id: string | number) {
+            return transport.request<void>(`${basePath}/${encodeURIComponent(String(id))}`, {
+                method: "DELETE",
+            });
+        },
+
+        ...(ws && {
+            listen(params: FindParams | undefined, onUpdate: (data: { data: Entity<M>[]; meta: any }) => void, onError?: (error: Error) => void) {
+                return ws.listenCollection(
+                    {
+                        path: slug,
+                        filter: parseWhereFilter(params?.where),
+                        limit: params?.limit,
+                        startAfter: params?.offset ? String(params.offset) : undefined,
+                        orderBy: params?.orderBy?.split(":")[0],
+                        order: params?.orderBy?.split(":")[1] as "asc" | "desc",
+                        searchString: params?.searchString
+                    },
+                    (entities: Entity[]) => {
+                        const requestedLimit = params?.limit || 20;
+                        onUpdate({
+                            data: entities as Entity<M>[],
+                            meta: {
+                                total: entities.length,
+                                limit: requestedLimit,
+                                offset: params?.offset || 0,
+                                hasMore: entities.length >= requestedLimit
+                            }
+                        });
+                    },
+                    onError
+                );
+            },
+
+            listenById(id: string | number, onUpdate: (data: Entity<M> | undefined) => void, onError?: (error: Error) => void) {
+                return ws.listenEntity(
+                    { path: slug, entityId: String(id) },
+                    (entity: Entity | null) => {
+                        if (entity) {
+                            onUpdate(entity as Entity<M>);
+                        } else {
+                            onUpdate(undefined);
+                        }
+                    },
+                    onError
+                );
+            }
+        }),
+
+        // Fluent builder instantiation
+        where(column: keyof M & string, operator: FilterOperator, value: any) {
+            return new QueryBuilder<M>(this as unknown as CollectionClient<M>).where(column, operator, value);
+        },
+        orderBy(column: keyof M & string, ascending?: "asc" | "desc") {
+            return new QueryBuilder<M>(this as unknown as CollectionClient<M>).orderBy(column, ascending);
+        },
+        limit(count: number) {
+            return new QueryBuilder<M>(this as unknown as CollectionClient<M>).limit(count);
+        },
+        offset(count: number) {
+            return new QueryBuilder<M>(this as unknown as CollectionClient<M>).offset(count);
+        },
+        search(searchString: string) {
+            return new QueryBuilder<M>(this as unknown as CollectionClient<M>).search(searchString);
+        },
+        include(...relations: string[]) {
+            return new QueryBuilder<M>(this as unknown as CollectionClient<M>).include(...relations);
+        }
+    };
+}

package/src/index.ts

@@ -0,0 +1,154 @@
+import { createTransport, RebaseClientConfig } from "./transport";
+import { createAuth, CreateAuthOptions } from "./auth";
+import { createAdmin, CreateAdminOptions } from "./admin";
+import { createCollectionClient, CollectionClient } from "./collection";
+
+export * from "./transport";
+export * from "./auth";
+export * from "./admin";
+export * from "./collection";
+export * from "./websocket";
+export * from "./storage";
+
+export interface CreateRebaseClientOptions extends RebaseClientConfig {
+    auth?: CreateAuthOptions;
+    admin?: CreateAdminOptions;
+}
+
+import { RebaseWebSocketClient } from "./websocket";
+import { RebaseClient as BaseRebaseClient, RebaseData, CollectionAccessor, StorageSource } from "@rebasepro/types";
+
+export type RebaseClient<DB = any> = BaseRebaseClient<DB> & {
+    setToken: (token: string | null) => void;
+    setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
+    setOnUnauthorized: (handler: () => Promise<boolean>) => void;
+    resolveToken: () => Promise<string | null>;
+    auth: ReturnType<typeof createAuth>;
+    admin: ReturnType<typeof createAdmin>;
+    ws?: RebaseWebSocketClient;
+    storage?: StorageSource;
+    call: <T = any>(endpoint: string, payload?: any) => Promise<T>;
+    data: RebaseData & {
+        collection<K extends keyof DB>(slug: Extract<K, string>): CollectionClient<
+            DB[K] extends { Row: infer R extends Record<string, any> } ? R : any
+        >;
+    } & {
+        [K in keyof DB]: CollectionClient<
+            DB[K] extends { Row: infer R extends Record<string, any> } ? R : any
+        >;
+    };
+};
+
+import { createStorage } from "./storage";
+
+/**
+ * Derive a WebSocket URL from an HTTP base URL.
+ * `http://` → `ws://`, `https://` → `wss://`.
+ */
+function deriveWebSocketUrl(baseUrl: string): string {
+    return baseUrl
+        .replace(/^https:\/\//, "wss://")
+        .replace(/^http:\/\//, "ws://")
+        .replace(/\/$/, "");
+}
+
+export function createRebaseClient<DB = any>(options: CreateRebaseClientOptions): RebaseClient<DB> {
+    const transport = createTransport(options);
+    const auth = createAuth(transport, options.auth);
+    const admin = createAdmin(transport, options.admin);
+    const storage = createStorage(transport);
+
+    const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
+
+    let ws: RebaseWebSocketClient | undefined;
+    if (resolvedWsUrl) {
+        ws = new RebaseWebSocketClient({
+            websocketUrl: resolvedWsUrl,
+            getAuthToken: async () => {
+                const session = await auth.getSession();
+                return session?.accessToken || options.token || "";
+            }
+        });
+
+        auth.onAuthStateChange((event, session) => {
+            if (!ws) return;
+            if (event === "SIGNED_OUT") {
+                ws.disconnect();
+            } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
+                if (session?.accessToken) {
+                    ws.authenticate(session.accessToken).catch(console.warn);
+                }
+            }
+        });
+    }
+
+    // Register transport callback for 401s after auth is instantiated
+    if (!options.onUnauthorized) {
+        options.onUnauthorized = async () => {
+            try {
+                await auth.refreshSession();
+                return true;
+            } catch (e) {
+                return false;
+            }
+        };
+    }
+
+    const collectionClients = new Map<string, CollectionClient<any>>();
+
+    function collection(slug: string): CollectionClient<any> {
+        if (!collectionClients.has(slug)) {
+            collectionClients.set(slug, createCollectionClient(transport, slug, ws));
+        }
+        return collectionClients.get(slug)!;
+    }
+
+    const dataTarget = { collection } as Record<string, any>;
+
+    const dataProxy = new Proxy(dataTarget, {
+        get(_target, prop: string | symbol) {
+            if (prop === "collection") {
+                return collection;
+            }
+            if (typeof prop === "symbol") return undefined;
+            if (typeof prop === "string" && prop !== "then" && prop !== "toJSON" && prop !== "$$typeof") {
+                return collection(prop);
+            }
+            return undefined;
+        }
+    });
+
+    const target = {
+        auth,
+        admin,
+        storage,
+        ws,
+        setToken: transport.setToken,
+        setAuthTokenGetter: transport.setAuthTokenGetter,
+        setOnUnauthorized: transport.setOnUnauthorized,
+        resolveToken: transport.resolveToken,
+        baseUrl: transport.baseUrl,
+        collection,
+        call: async <T = any>(endpoint: string, payload?: any): Promise<T> => {
+            const prefix = endpoint.startsWith("/") ? "" : "/";
+            const res = await transport.request<{ data: T }>(`${prefix}${endpoint}`, {
+                method: "POST",
+                body: payload ? JSON.stringify(payload) : undefined
+            });
+            return res.data ?? (res as unknown as T);
+        },
+        data: dataProxy
+    } as unknown as RebaseClient<DB>;
+
+    return new Proxy(target, {
+        get(obj, prop: string | symbol) {
+            if (prop in obj) {
+                return (obj as Record<string, unknown>)[prop as string];
+            }
+            if (typeof prop === "string" && prop !== "then") {
+                return collection(prop as Extract<keyof DB, string>);
+            }
+            return undefined;
+        }
+    }) as RebaseClient<DB>;
+}

package/src/query_builder.ts

@@ -0,0 +1,126 @@
+import { FindParams, Entity } from "@rebasepro/types";
+import { FindResponse } from "./transport";
+import { CollectionClient } from "./collection";
+
+export type FilterOperator =
+    | "eq" | "neq" | "gt" | "gte" | "lt" | "lte"
+    | "in" | "nin" | "cs" | "csa"
+    | "==" | "!=" | ">" | ">=" | "<" | "<="
+    | "array-contains" | "array-contains-any"
+    | "not-in";
+
+/**
+ * Maps standard operators to Rebase backend's string-based operators
+ */
+function mapOperator(op: FilterOperator): string {
+    switch (op) {
+        case "==": return "eq";
+        case "!=": return "neq";
+        case ">": return "gt";
+        case ">=": return "gte";
+        case "<": return "lt";
+        case "<=": return "lte";
+        case "array-contains": return "cs";
+        case "array-contains-any": return "csa";
+        case "not-in": return "nin";
+        default: return op;
+    }
+}
+
+export class QueryBuilder<M extends Record<string, any> = any> {
+    private params: FindParams = { where: {} };
+
+    constructor(private collection: CollectionClient<M>) {}
+
+    /**
+     * Add a filter condition to your query.
+     * @example 
+     * client.collection('users').where('age', '>=', 18).find()
+     */
+    where(column: keyof M & string, operator: FilterOperator, value: any): this {
+        if (!this.params.where) {
+            this.params.where = {};
+        }
+
+        const mappedOp = mapOperator(operator);
+        let formattedValue = value;
+        
+        // Handle arrays for in, nin, cs, csa
+        if (Array.isArray(value) && ["in", "nin", "cs", "csa"].includes(mappedOp)) {
+            formattedValue = `(${value.join(",")})`;
+        } else if (value === null) {
+            formattedValue = "null";
+        }
+
+        this.params.where[column] = mappedOp === "eq" ? String(formattedValue) : `${mappedOp}.${formattedValue}`;
+        return this;
+    }
+
+    /**
+     * Order the results by a specific column.
+     * @example 
+     * client.collection('users').orderBy('createdAt', 'desc').find()
+     */
+    orderBy(column: keyof M & string, ascending: "asc" | "desc" = "asc"): this {
+        this.params.orderBy = `${column}:${ascending}`;
+        return this;
+    }
+
+    /**
+     * Limit the number of results returned.
+     */
+    limit(count: number): this {
+        this.params.limit = count;
+        return this;
+    }
+
+    /**
+     * Skip the first N results.
+     */
+    offset(count: number): this {
+        this.params.offset = count;
+        return this;
+    }
+
+    /**
+     * Set a free-text search string if supported by the backend.
+     */
+    search(searchString: string): this {
+        this.params.searchString = searchString;
+        return this;
+    }
+
+    /**
+     * Include related entities in the response.
+     * Relations will be populated with full entity data instead of just IDs.
+     *
+     * @param relations - Relation names to include, or "*" for all.
+     * @example
+     * // Include specific relations
+     * client.data.posts.include("tags", "author").find()
+     *
+     * // Include all relations
+     * client.data.posts.include("*").find()
+     */
+    include(...relations: string[]): this {
+        this.params.include = relations;
+        return this;
+    }
+
+    /**
+     * Execute the find query and return the results.
+     */
+    async find(): Promise<FindResponse<M>> {
+        return this.collection.find(this.params) as Promise<FindResponse<M>>;
+    }
+
+    /**
+     * Listen to realtime updates matching this query.
+     */
+    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void {
+        if (!this.collection.listen) {
+            throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
+        }
+        return this.collection.listen(this.params, onUpdate as unknown as (data: { data: Entity<M>[]; meta: any }) => void, onError);
+    }
+}

package/src/storage.ts

@@ -0,0 +1,181 @@
+import { StorageSource, UploadFileProps, UploadFileResult, DownloadConfig, StorageListResult } from "@rebasepro/types";
+import { Transport } from "./transport";
+
+export function createStorage(transport: Transport): StorageSource {
+    const urlsCache = new Map<string, DownloadConfig>();
+    
+    // We expect the transport to point to /api, and storage endpoints handle /api/storage internally if they are relative?
+    // Wait, useBackendStorageSource uses `${apiUrl}/api/storage` directly.
+    // Transport has `.request` which hits `${config.baseUrl}${config.apiPath}${path}`.
+    // Assuming `config.apiPath` is "/api", we just request(`/storage/upload`, ...).
+
+    async function uploadFile({
+        file,
+        fileName,
+        path,
+        metadata,
+        bucket
+    }: UploadFileProps): Promise<UploadFileResult> {
+        const formData = new FormData();
+        formData.append("file", file);
+
+        if (fileName) formData.append("fileName", fileName);
+        if (path) formData.append("path", path);
+        if (bucket) formData.append("bucket", bucket);
+
+        if (metadata) {
+            for (const [key, value] of Object.entries(metadata)) {
+                if (value !== undefined && value !== null) {
+                    formData.append(
+                        `metadata_${key}`,
+                        typeof value === "string" ? value : JSON.stringify(value)
+                    );
+                }
+            }
+        }
+
+        // We use fetchFn directly if we need to do multipart boundary, but Transport.request might override Content-Type?
+        // Wait, transport.request defaults to application/json. We must remove Content-Type header or allow it to be evaluated by fetch when body is FormData!
+        const result = await transport.request<{ data: UploadFileResult }>("/storage/upload", {
+            method: "POST",
+            body: formData,
+            headers: {
+                // transport.request merges headers, so to prevent it setting application/json we can delete it 
+                // in transport if body is FormData, or we can explicitly set it to an empty string.
+                // Let's rely on standard behaviour for now and adjust transport if it fails.
+            }
+        });
+
+        return result.data;
+    }
+
+    async function getDownloadURL(
+        pathOrUrl: string,
+        bucket?: string
+    ): Promise<DownloadConfig> {
+        const cacheKey = bucket ? `${bucket}/${pathOrUrl}` : pathOrUrl;
+        const cached = urlsCache.get(cacheKey);
+        if (cached) return cached;
+
+        let filePath = pathOrUrl;
+
+        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+            filePath = filePath.substring(filePath.indexOf("://") + 3);
+        }
+
+        if (bucket && filePath && !filePath.startsWith(bucket)) {
+            filePath = `${bucket}/${filePath}`;
+        }
+
+        if (!filePath || filePath.trim() === '' || filePath === '/') {
+            return { url: null, fileNotFound: true };
+        }
+
+        try {
+            const result = await transport.request<{ data: any }>(`/storage/metadata/${filePath}`);
+            
+            const activeToken = await transport.resolveToken();
+            const tokenQuery = activeToken ? `?token=${activeToken}` : '';
+
+            const downloadConfig: DownloadConfig = {
+                url: `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`,
+                metadata: result.data
+            };
+
+            urlsCache.set(cacheKey, downloadConfig);
+            return downloadConfig;
+        } catch (e: unknown) {
+            if (e instanceof Error && 'status' in e && (e as { status: number }).status === 404) {
+                return { url: null, fileNotFound: true };
+            }
+            throw e;
+        }
+    }
+
+    async function getFile(
+        path: string,
+        bucket?: string
+    ): Promise<File | null> {
+        let filePath = path;
+
+        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+            filePath = filePath.substring(filePath.indexOf("://") + 3);
+        }
+
+        if (bucket && filePath && !filePath.startsWith(bucket)) {
+            filePath = `${bucket}/${filePath}`;
+        }
+
+        if (!filePath || filePath.trim() === '' || filePath === '/') {
+            return null;
+        }
+
+        // We must use plain fetch because transport.request expects JSON response, but here we want a Blob.
+        const url = `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`;
+        
+        // This is a bit manual, but necessary for blob handling
+        const response = await transport.fetchFn(url, {
+            headers: transport.getHeaders ? transport.getHeaders() : {}
+        });
+
+        if (response.status === 404) return null;
+        if (!response.ok) throw new Error("Failed to get file");
+
+        const blob = await response.blob();
+        const fileName = filePath.split("/").pop() || "file";
+        return new File([blob], fileName, { type: blob.type });
+    }
+
+    async function deleteFile(
+        path: string,
+        bucket?: string
+    ): Promise<void> {
+        let filePath = path;
+
+        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+            filePath = filePath.substring(filePath.indexOf("://") + 3);
+        }
+
+        if (bucket && filePath && !filePath.startsWith(bucket)) {
+            filePath = `${bucket}/${filePath}`;
+        }
+
+        if (!filePath || filePath.trim() === '' || filePath === '/') {
+            return;
+        }
+
+        try {
+            await transport.request(`/storage/file/${filePath}`, { method: "DELETE" });
+        } catch (e: unknown) {
+            if (!(e instanceof Error && 'status' in e && (e as { status: number }).status === 404)) throw e;
+        }
+
+        urlsCache.delete(bucket ? `${bucket}/${path}` : path);
+    }
+
+    async function list(
+        path: string,
+        options?: {
+            bucket?: string;
+            maxResults?: number;
+            pageToken?: string;
+        }
+    ): Promise<StorageListResult> {
+        const params = new URLSearchParams();
+        if (path) params.set("path", path);
+        if (options?.bucket) params.set("bucket", options.bucket);
+        if (options?.maxResults) params.set("maxResults", String(options.maxResults));
+        if (options?.pageToken) params.set("pageToken", options.pageToken);
+
+        const result = await transport.request<{ data: StorageListResult }>(`/storage/list?${params.toString()}`);
+        return result.data;
+    }
+
+    return {
+        uploadFile,
+        getDownloadURL,
+        getFile,
+        deleteFile,
+        list
+    };
+}