@rebasepro/client 0.0.1-canary.09e5ec5

package/src/collection.ts

@@ -0,0 +1,249 @@
+import { Transport, FindParams, buildQueryString } from "./transport";
+import { RebaseWebSocketClient } from "./websocket";
+import { Entity, FilterValues, WhereFilterOp, CollectionAccessor, WhereFieldValue, FindResponse } from "@rebasepro/types";
+
+import { FilterOperator, QueryBuilder } from "./query_builder";
+
+function parseWhereFilter(where?: Record<string, WhereFieldValue>): FilterValues<string> | undefined {
+    if (!where) return undefined;
+    const filters: Record<string, [WhereFilterOp, unknown]> = {};
+    for (const [key, rawValue] of Object.entries(where)) {
+        // Handle null → equality
+        if (rawValue === null) {
+            filters[key] = ["==", null];
+            continue;
+        }
+
+        // Handle boolean → equality
+        if (typeof rawValue === "boolean") {
+            filters[key] = ["==", rawValue];
+            continue;
+        }
+
+        // Handle number → equality
+        if (typeof rawValue === "number") {
+            filters[key] = ["==", rawValue];
+            continue;
+        }
+
+        // Handle tuple: [operator, value]
+        if (Array.isArray(rawValue) && rawValue.length === 2) {
+            const [rawOp, val] = rawValue;
+            const OP_TO_FILTER: 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"
+            };
+            filters[key] = [OP_TO_FILTER[rawOp] ?? "==", val];
+            continue;
+        }
+
+        // Handle string (original PostgREST format)
+        const value = String(rawValue);
+        const dotIndex = value.indexOf(".");
+        if (dotIndex > 0) {
+            const opStr = value.substring(0, dotIndex);
+            const valStr = value.substring(dotIndex + 1);
+            let op: WhereFilterOp = "==";
+            let val: string | number | boolean | null | string[] = 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) && key !== "id" && !key.endsWith("_id")) 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, unknown>>(row: Record<string, unknown>, slug: string): Entity<M> {
+    return {
+        id: row.id as string | number,
+        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, unknown> = Record<string, unknown>> extends CollectionAccessor<M> {
+    // Fluent Query Builder
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): 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, unknown> = Record<string, unknown>>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M> {
+    const basePath = `/data/${slug}`;
+
+    const client: CollectionClient<M> = {
+        async find(params?: FindParams): Promise<FindResponse<M>> {
+            const qs = buildQueryString(params);
+            const raw = await transport.request<{ data: Record<string, unknown>[]; meta: FindResponse<M>["meta"] }>(basePath + qs, { method: "GET" });
+            return {
+                data: (raw.data || []).map((row: Record<string, unknown>) => rowToEntity<M>(row, slug)),
+                meta: raw.meta
+            };
+        },
+
+        async findById(id: string | number) {
+            const raw = await transport.request<Record<string, unknown>>(`${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, unknown>>(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, unknown>>(`${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"
+            });
+        },
+
+        // Fluent builder instantiation
+        where(column: keyof M & string, operator: FilterOperator, value: unknown) {
+            return new QueryBuilder<M>(client).where(column, operator, value);
+        },
+        orderBy(column: keyof M & string, ascending?: "asc" | "desc") {
+            return new QueryBuilder<M>(client).orderBy(column, ascending);
+        },
+        limit(count: number) {
+            return new QueryBuilder<M>(client).limit(count);
+        },
+        offset(count: number) {
+            return new QueryBuilder<M>(client).offset(count);
+        },
+        search(searchString: string) {
+            return new QueryBuilder<M>(client).search(searchString);
+        },
+        include(...relations: string[]) {
+            return new QueryBuilder<M>(client).include(...relations);
+        }
+    };
+
+    if (ws) {
+        client.listen = (params: FindParams | undefined, onUpdate: (response: FindResponse<M>) => 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
+            );
+        };
+
+        client.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
+            );
+        };
+    }
+
+    return client;
+}

package/src/cron.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, jest, beforeEach } from "@jest/globals";
+import { createCron } from "./cron";
+import type { Transport } from "./transport";
+
+// ─── Mock Transport ─────────────────────────────────────────────────
+
+function createMockTransport() {
+    const requestMock = jest.fn() as unknown as jest.MockedFunction<Transport["request"]>;
+
+    return {
+        request: requestMock,
+        setToken: jest.fn(),
+        setAuthTokenGetter: jest.fn(),
+        setOnUnauthorized: jest.fn(),
+        get baseUrl() { return "http://test"; },
+        get apiPath() { return "/api"; },
+        get fetchFn() { return globalThis.fetch; },
+        getHeaders: () => ({}),
+        resolveToken: async () => null
+    };
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe("createCron", () => {
+    let transport: ReturnType<typeof createMockTransport>;
+
+    beforeEach(() => {
+        transport = createMockTransport();
+    });
+
+    describe("listJobs", () => {
+        it("calls GET /cron", async () => {
+            transport.request.mockResolvedValue({ jobs: [] });
+            const cron = createCron(transport);
+
+            const result = await cron.listJobs();
+
+            expect(transport.request).toHaveBeenCalledWith("/cron", { method: "GET" });
+            expect(result).toEqual({ jobs: [] });
+        });
+    });
+
+    describe("getJob", () => {
+        it("calls GET /cron/:id with encoded ID", async () => {
+            transport.request.mockResolvedValue({ job: { id: "my-job" } });
+            const cron = createCron(transport);
+
+            await cron.getJob("my-job");
+
+            expect(transport.request).toHaveBeenCalledWith("/cron/my-job", { method: "GET" });
+        });
+
+        it("encodes special characters in job ID", async () => {
+            transport.request.mockResolvedValue({ job: {} });
+            const cron = createCron(transport);
+
+            await cron.getJob("job with spaces");
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/cron/job%20with%20spaces",
+                { method: "GET" }
+            );
+        });
+    });
+
+    describe("triggerJob", () => {
+        it("calls POST /cron/:id/trigger", async () => {
+            transport.request.mockResolvedValue({ log: {},
+job: {} });
+            const cron = createCron(transport);
+
+            await cron.triggerJob("my-job");
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/cron/my-job/trigger",
+                { method: "POST" }
+            );
+        });
+    });
+
+    describe("getJobLogs", () => {
+        it("calls GET /cron/:id/logs without limit", async () => {
+            transport.request.mockResolvedValue({ logs: [] });
+            const cron = createCron(transport);
+
+            await cron.getJobLogs("my-job");
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/cron/my-job/logs",
+                { method: "GET" }
+            );
+        });
+
+        it("appends limit query param when provided", async () => {
+            transport.request.mockResolvedValue({ logs: [] });
+            const cron = createCron(transport);
+
+            await cron.getJobLogs("my-job", { limit: 5 });
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/cron/my-job/logs?limit=5",
+                { method: "GET" }
+            );
+        });
+    });
+
+    describe("toggleJob", () => {
+        it("calls PUT /cron/:id with enabled=true", async () => {
+            transport.request.mockResolvedValue({ job: {} });
+            const cron = createCron(transport);
+
+            await cron.toggleJob("my-job", true);
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/cron/my-job",
+                {
+                    method: "PUT",
+                    body: JSON.stringify({ enabled: true })
+                }
+            );
+        });
+
+        it("calls PUT /cron/:id with enabled=false", async () => {
+            transport.request.mockResolvedValue({ job: {} });
+            const cron = createCron(transport);
+
+            await cron.toggleJob("my-job", false);
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/cron/my-job",
+                {
+                    method: "PUT",
+                    body: JSON.stringify({ enabled: false })
+                }
+            );
+        });
+    });
+
+    describe("custom cronPath", () => {
+        it("uses custom path prefix", async () => {
+            transport.request.mockResolvedValue({ jobs: [] });
+            const cron = createCron(transport, { cronPath: "/admin/scheduled" });
+
+            await cron.listJobs();
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/admin/scheduled",
+                { method: "GET" }
+            );
+        });
+
+        it("custom path applies to all methods", async () => {
+            transport.request.mockResolvedValue({});
+            const cron = createCron(transport, { cronPath: "/v2/cron" });
+
+            await cron.getJob("x");
+            expect(transport.request).toHaveBeenCalledWith("/v2/cron/x", { method: "GET" });
+
+            await cron.triggerJob("x");
+            expect(transport.request).toHaveBeenCalledWith("/v2/cron/x/trigger", { method: "POST" });
+        });
+    });
+});

package/src/cron.ts

@@ -0,0 +1,62 @@
+import { Transport } from "./transport";
+import type { CronJobStatus, CronJobLogEntry } from "@rebasepro/types";
+
+export interface CreateCronOptions {
+    cronPath?: string;
+}
+
+export function createCron(transport: Transport, options?: CreateCronOptions) {
+    const cronPath = options?.cronPath || "/cron";
+
+    async function listJobs(): Promise<{ jobs: CronJobStatus[] }> {
+        return transport.request<{ jobs: CronJobStatus[] }>(cronPath, { method: "GET" });
+    }
+
+    async function getJob(jobId: string): Promise<{ job: CronJobStatus }> {
+        return transport.request<{ job: CronJobStatus }>(
+            cronPath + "/" + encodeURIComponent(jobId),
+            { method: "GET" }
+        );
+    }
+
+    async function triggerJob(jobId: string): Promise<{ log: CronJobLogEntry; job: CronJobStatus }> {
+        return transport.request<{ log: CronJobLogEntry; job: CronJobStatus }>(
+            cronPath + "/" + encodeURIComponent(jobId) + "/trigger",
+            { method: "POST" }
+        );
+    }
+
+    async function getJobLogs(
+        jobId: string,
+        options?: { limit?: number }
+    ): Promise<{ logs: CronJobLogEntry[] }> {
+        const params = new URLSearchParams();
+        if (options?.limit !== undefined) params.set("limit", String(options.limit));
+        const qs = params.toString();
+        return transport.request<{ logs: CronJobLogEntry[] }>(
+            cronPath + "/" + encodeURIComponent(jobId) + "/logs" + (qs ? "?" + qs : ""),
+            { method: "GET" }
+        );
+    }
+
+    async function toggleJob(
+        jobId: string,
+        enabled: boolean
+    ): Promise<{ job: CronJobStatus }> {
+        return transport.request<{ job: CronJobStatus }>(
+            cronPath + "/" + encodeURIComponent(jobId),
+            {
+                method: "PUT",
+                body: JSON.stringify({ enabled })
+            }
+        );
+    }
+
+    return {
+        listJobs,
+        getJob,
+        triggerJob,
+        getJobLogs,
+        toggleJob
+    };
+}

package/src/index.ts

@@ -0,0 +1,167 @@
+import { createTransport, RebaseClientConfig } from "./transport";
+import { createAuth, CreateAuthOptions } from "./auth";
+import { createAdmin, CreateAdminOptions } from "./admin";
+import { createCron, CreateCronOptions } from "./cron";
+import { createCollectionClient, CollectionClient } from "./collection";
+
+export * from "./transport";
+export * from "./auth";
+export * from "./admin";
+export * from "./cron";
+export * from "./collection";
+export * from "./websocket";
+export * from "./storage";
+export * from "./reviver";
+
+export interface CreateRebaseClientOptions extends RebaseClientConfig {
+    auth?: CreateAuthOptions;
+    admin?: CreateAdminOptions;
+    cron?: CreateCronOptions;
+}
+
+import { RebaseWebSocketClient } from "./websocket";
+import { RebaseClient as BaseRebaseClient, RebaseData, CollectionAccessor, StorageSource } from "@rebasepro/types";
+import { toSnakeCase } from "@rebasepro/utils";
+
+export type RebaseClient<DB = Record<string, unknown>> = 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>;
+    cron: ReturnType<typeof createCron>;
+    ws?: RebaseWebSocketClient;
+    storage?: StorageSource;
+    call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
+    data: RebaseData & {
+        collection<K extends keyof DB>(slug: Extract<K, string>): CollectionClient<
+            DB[K] extends { Row: infer R extends Record<string, unknown> } ? R : Record<string, unknown>
+        >;
+    } & {
+        [K in keyof DB]: CollectionClient<
+            DB[K] extends { Row: infer R extends Record<string, unknown> } ? R : Record<string, unknown>
+        >;
+    };
+};
+
+import { createStorage } from "./storage";
+
+/**
+ * Derive a WebSocket URL from an HTTP base URL.
+ * `http://` → `ws://`, `https://` → `wss://`.
+ */
+function deriveWebSocketUrl(baseUrl?: string): string {
+    if (!baseUrl) {
+        // If no baseUrl is provided, we can try to derive it from the window object if in browser
+        if (typeof window !== "undefined") {
+            const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+            return `${protocol}//${window.location.host}`;
+        }
+        return "";
+    }
+    return baseUrl
+        .replace(/^https:\/\//, "wss://")
+        .replace(/^http:\/\//, "ws://")
+        .replace(/\/$/, "");
+}
+
+export function createRebaseClient<DB = Record<string, unknown>>(options: CreateRebaseClientOptions): RebaseClient<DB> {
+    const transport = createTransport(options);
+    const auth = createAuth(transport, options.auth);
+    const admin = createAdmin(transport, options.admin);
+    const cron = createCron(transport, options.cron);
+    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.
+    // IMPORTANT: We must use transport.setOnUnauthorized() here — NOT set
+    // options.onUnauthorized — because the transport was already created above
+    // and captured the (undefined) value from the config closure.
+    if (!options.onUnauthorized) {
+        transport.setOnUnauthorized(async () => {
+            try {
+                await auth.refreshSession();
+                return true;
+            } catch (e) {
+                return false;
+            }
+        });
+    }
+
+    const collectionClients = new Map<string, CollectionClient<Record<string, unknown>>>();
+
+    function collection(slug: string): CollectionClient<Record<string, unknown>> {
+        if (!collectionClients.has(slug)) {
+            collectionClients.set(slug, createCollectionClient(transport, slug, ws));
+        }
+        return collectionClients.get(slug)!;
+    }
+
+    const dataTarget = { collection } as Record<string, unknown>;
+
+    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") {
+                // Convert camelCase property names to snake_case slugs.
+                // e.g. `companyMembers` → `company_members`
+                const slug = toSnakeCase(prop);
+                return collection(slug);
+            }
+            return undefined;
+        }
+    });
+
+    const target = {
+        auth,
+        admin,
+        cron,
+        storage,
+        ws,
+        setToken: transport.setToken,
+        setAuthTokenGetter: transport.setAuthTokenGetter,
+        setOnUnauthorized: transport.setOnUnauthorized,
+        resolveToken: transport.resolveToken,
+        baseUrl: transport.baseUrl,
+        collection,
+        call: async <T = unknown>(endpoint: string, payload?: unknown): 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,
+        email: undefined
+    } as unknown as RebaseClient<DB>;
+
+    return target;
+}