@rebasepro/client 0.17.3 → 0.18.0

package/src/realtime-subscription-key.test.ts

@@ -1,92 +0,0 @@
-import { jest } from "@jest/globals";
-import { RebaseWebSocketClient } from "./websocket";
-import { or, cond } from "@rebasepro/common";
-
-/**
- * Two subscriptions are the same subscription only when they ask for the same
- * rows. The key that decides this was built from a hand-listed subset of the
- * props, so any field left off it made two different queries collide — and the
- * second listener was handed the first one's rows, which is worse than not
- * subscribing at all.
- */
-
-function fakeSocket() {
-    const sent: Record<string, unknown>[] = [];
-
-    class FakeWS {
-        static readonly OPEN = 1;
-        readyState = 1;
-        onopen: (() => void) | null = null;
-        onclose: (() => void) | null = null;
-        onerror: (() => void) | null = null;
-        onmessage: ((event: { data: string }) => void) | null = null;
-
-        constructor(public url: string) {
-            setTimeout(() => this.onopen?.(), 0);
-        }
-
-        send(raw: string) {
-            const message = JSON.parse(raw) as Record<string, unknown>;
-            sent.push(message);
-            if (message.type === "AUTHENTICATE") {
-                setTimeout(() => this.onmessage?.({
-                    data: JSON.stringify({ type: "AUTH_SUCCESS", requestId: message.requestId })
-                }), 0);
-            }
-        }
-
-        close() { /* noop */ }
-    }
-
-    return { FakeWS: FakeWS as unknown as typeof WebSocket, sent };
-}
-
-function subscribeFrames(sent: Record<string, unknown>[]) {
-    return sent.filter((m) => m.type === "subscribe_collection");
-}
-
-describe("collection subscription identity", () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    async function twoSubscriptions(
-        a: Record<string, unknown>,
-        b: Record<string, unknown>
-    ) {
-        const { FakeWS, sent } = fakeSocket();
-        const client = new RebaseWebSocketClient({
-            websocketUrl: "ws://localhost:1234",
-            WebSocket: FakeWS,
-            getAuthToken: async () => "token"
-        });
-        client.listenCollection({ path: "posts", ...a } as never, () => {});
-        client.listenCollection({ path: "posts", ...b } as never, () => {});
-        await jest.advanceTimersByTimeAsync(50);
-        return subscribeFrames(sent);
-    }
-
-    it("treats different offsets as different subscriptions", async () => {
-        // Page one and page two of the same live list. Sharing a subscription
-        // here shows page one's rows on page two.
-        const frames = await twoSubscriptions({ limit: 10, offset: 0 }, { limit: 10, offset: 10 });
-        expect(frames).toHaveLength(2);
-    });
-
-    it("treats different logical groups as different subscriptions", async () => {
-        const frames = await twoSubscriptions(
-            { logical: or(cond("status", "==", "draft")) },
-            { logical: or(cond("status", "==", "published")) }
-        );
-        expect(frames).toHaveLength(2);
-    });
-
-    it("still shares one subscription for genuinely identical queries", async () => {
-        // The de-duplication itself is the point of the key: two components
-        // watching the same list must not open two server subscriptions.
-        const frames = await twoSubscriptions(
-            { limit: 10, offset: 10, logical: or(cond("status", "==", "draft")) },
-            { limit: 10, offset: 10, logical: or(cond("status", "==", "draft")) }
-        );
-        expect(frames).toHaveLength(1);
-    });
-});

package/src/reviver.ts

@@ -1,39 +0,0 @@
-import { EntityReference, EntityRelation, GeoPoint, Vector } from "@rebasepro/types";
-
-export function rebaseReviver(_key: string, value: unknown): unknown {
-    if (value && typeof value === "object" && "__type" in value) {
-        const record = value as Record<string, unknown>;
-        switch (record.__type) {
-            case "date":
-            case "Date": {
-                if (typeof record.value !== "string") {
-                    return value;
-                }
-                const date = new Date(record.value);
-                return isNaN(date.getTime()) ? null : date;
-            }
-            case "reference":
-            case "EntityReference":
-                return new EntityReference({
-                    id: String(record.id),
-                    path: record.path as string,
-                    driver: record.driver as string | undefined,
-                    databaseId: record.databaseId as string | undefined
-                });
-            case "relation":
-            case "EntityRelation":
-                return new EntityRelation(
-                    record.id as string | number,
-                    record.path as string,
-                    record.data as Record<string, unknown> | undefined
-                );
-            case "GeoPoint":
-                return new GeoPoint(record.latitude as number, record.longitude as number);
-            case "Vector":
-                return new Vector(record.value as number[]);
-            default:
-                return value;
-        }
-    }
-    return value;
-}

package/src/sdk_query_builder.ts

@@ -1,206 +0,0 @@
-import {
-    FindParams,
-    FindResult,
-    LogicalCondition,
-    OrderByTuple,
-    SDKCollectionClient,
-    SDKQueryBuilderInterface,
-    WhereFilterOp,
-    WhereValueFor,
-    type ComputedSortField
-} from "@rebasepro/types";
-import { normalizeOrderBy } from "@rebasepro/common";
-
-/**
- * SDK Query Builder — returns flat rows (`FindResult<M>`) instead of
- * Entity-wrapped results (`FindResponse<M>`).
- *
- * @example
- * const { data } = await rebase.data.posts
- *     .where("status", "==", "published")
- *     .orderBy("created_at", "desc")
- *     .limit(10)
- *     .find();
- *
- * console.log(data[0].title); // flat access
- */
-export class SDKQueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements SDKQueryBuilderInterface<M> {
-    // The accumulator stays keyed by plain `string`: it is written through
-    // `where()` / `orderBy()` below, whose own parameters are typed against `M`,
-    // and a `Partial<Record<FieldPath<M>, …>>` is read-only under a generic `M`
-    // (TS2862) so it cannot be built up in place. The typing users see is on the
-    // methods; this field is the buffer behind them, cast once on the way out.
-    private params: FindParams = { where: {} };
-
-    constructor(private collection: SDKCollectionClient<M>) {}
-
-    /**
-     * Add a filter condition to your query.
-     * @example
-     * client.data.users.where('age', '>=', 18).find()
-     */
-    where<K extends keyof M & string, Op extends WhereFilterOp>(column: K, operator: Op, value: WhereValueFor<Op, 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;
-    }
-
-    /**
-     * Order the results by a specific column.
-     *
-     * Call it again to add a tie-breaker rather than replace the sort: keys
-     * apply in the order they were added, so
-     * `.orderBy("roles").orderBy("created_at", "desc")` sorts by role and
-     * shows the newest first within each one.
-     */
-    orderBy(column: (keyof M & string) | ComputedSortField, direction: "asc" | "desc" = "asc"): this {
-        const existing = normalizeOrderBy(this.params.orderBy) ?? [];
-        this.params.orderBy = [...existing, [column, direction] as OrderByTuple];
-        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.
-     *
-     * By default this is a substring match across the collection's top-level
-     * string properties. A Postgres collection that declares a `search` block
-     * gets ranked full-text matching over the fields it named instead, and each
-     * row comes back with a `_score` you can sort on:
-     *
-     * ```ts
-     * client.data.talents.search("auditor iso 14001").orderBy("_score", "desc").find()
-     * ```
-     *
-     * Pass `{ explain: true }` to have each row report which of the declared
-     * fields matched, with a highlighted snippet, on `_matches`:
-     *
-     * ```ts
-     * const { data } = await client.data.talents.search("iso 14001", { explain: true }).find();
-     * data[0]._matches
-     * // [{ field: "questionnaire.certifications", snippet: "<mark>ISO</mark> <mark>14001</mark> Lead Auditor" }]
-     * ```
-     */
-    search(searchString: string, options?: { explain?: boolean }): this {
-        this.params.searchString = searchString;
-        if (options?.explain !== undefined) this.params.searchExplain = options.explain;
-        return this;
-    }
-
-    /**
-     * Order rows by nearest-neighbour distance to `vector`.
-     *
-     * The server has supported this from the REST layer since vectors landed;
-     * this is the SDK reaching it. Results come back closest-first with a
-     * `_distance` on each row, and any `where` / `orderBy` on the same query is
-     * a filter applied before the ordering — distance decides the order.
-     *
-     * You supply the query vector. Rebase stores and searches embeddings; it
-     * does not produce them, so this is where whatever model you already use
-     * for the stored vectors gets called.
-     *
-     * @param property - Name of the `vector` property to compare against.
-     * @param vector - The query embedding. Its length must match the property's
-     *                 declared `dimensions`, or the server answers 400.
-     * @example
-     * client.data.docs.vectorSearch("embedding", queryVector, { threshold: 0.35 }).limit(10).find()
-     */
-    vectorSearch(
-        property: string,
-        vector: number[],
-        options?: { distance?: "cosine" | "l2" | "inner_product"; threshold?: number }
-    ): this {
-        this.params.vectorSearch = {
-            property,
-            vector,
-            ...(options?.distance !== undefined && { distance: options.distance }),
-            ...(options?.threshold !== undefined && { threshold: options.threshold })
-        };
-        return this;
-    }
-
-    /**
-     * Include related entities in the response.
-     * Relations will be populated with full data instead of just IDs.
-     *
-     * @param relations - Relation names to include, or "*" for all.
-     * @example
-     * client.data.posts.include("tags", "author").find()
-     */
-    include(...relations: string[]): this {
-        this.params.include = relations;
-        return this;
-    }
-
-    /**
-     * Execute the find query and return the results as flat rows.
-     */
-    async find(): Promise<FindResult<M>> {
-        return this.collection.find(this.params as FindParams<M>);
-    }
-
-    /**
-     * Count the records matching this query.
-     */
-    async count(): Promise<number> {
-        if (!this.collection.count) {
-            throw new Error("count() is not supported by this collection client.");
-        }
-        return this.collection.count(this.params as FindParams<M>);
-    }
-
-    /**
-     * Listen to realtime updates matching this query.
-     */
-    listen(onUpdate: (data: FindResult<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, " +
-                "and not when it was created with realtime: false."
-            );
-        }
-        return this.collection.listen(this.params as FindParams<M>, onUpdate, onError);
-    }
-}

package/src/storage-key-encoding.test.ts

@@ -1,65 +0,0 @@
-/**
- * Storage keys in a URL path.
- *
- * Every call in `storage.ts` interpolated the key raw, and the server decodes
- * what it receives. Three ordinary filenames did three different wrong things,
- * all measured against a real Hono route before this was written:
- *
- *   `Invoice #12.pdf`  the `#` began the fragment, so the server saw
- *                      `default/Invoice ` — a key that is not the file — and a
- *                      scoped `?token=` after it was swallowed with it
- *   `100% done.png`    `decodeURIComponent` threw URIError, answered 500
- *   `a%2Fb.png`        decoded to `a/b.png`, silently resolving a DIFFERENT
- *                      object
- *
- * The last is the one worth the test: no error, no log, the wrong bytes.
- */
-import { encodeStorageKey } from "./storage";
-
-describe("encodeStorageKey", () => {
-    it("leaves an ordinary key untouched", () => {
-        // The no-op property: every key that already worked still produces the
-        // same URL, so nothing cached or CDN-fronted moves.
-        expect(encodeStorageKey("default/photo.png")).toBe("default/photo.png");
-        expect(encodeStorageKey("public/a/b/c.jpg")).toBe("public/a/b/c.jpg");
-    });
-
-    it("keeps the key's own separator", () => {
-        // `/` separates bucket from path and folder from file. Encoding it
-        // would make every existing key unresolvable.
-        expect(encodeStorageKey("a/b/c")).toBe("a/b/c");
-    });
-
-    it.each([
-        ["default/Invoice #12.pdf", "default/Invoice%20%2312.pdf"],
-        ["default/100% done.png", "default/100%25%20done.png"],
-        ["default/a%2Fb.png", "default/a%252Fb.png"],
-        ["default/a+b.png", "default/a%2Bb.png"],
-        ["default/naïve café.png", "default/na%C3%AFve%20caf%C3%A9.png"]
-    ])("encodes %s", (input, expected) => {
-        expect(encodeStorageKey(input)).toBe(expected);
-    });
-
-    it("keeps a key containing an encoded slash distinct from a real one", () => {
-        // The silent one. `a%2Fb.png` is a legal object name and it is not
-        // `a/b.png`; before this they resolved to the same object.
-        expect(encodeStorageKey("default/a%2Fb.png"))
-            .not.toBe(encodeStorageKey("default/a/b.png"));
-    });
-
-    it("survives a round trip through the server's decode", () => {
-        // The server runs `decodeURIComponent` over the whole path. Anything
-        // that does not come back unchanged is a key that resolves to the
-        // wrong object, or a 500.
-        for (const key of [
-            "default/photo.png",
-            "default/Invoice #12.pdf",
-            "default/100% done.png",
-            "default/a%2Fb.png",
-            "default/50%.png",
-            "default/naïve café.png"
-        ]) {
-            expect(decodeURIComponent(encodeStorageKey(key))).toBe(key);
-        }
-    });
-});

package/src/storage-registry.ts

@@ -1,102 +0,0 @@
-/**
- * Client-side storage source registry.
- *
- * Manages multiple `StorageSource` instances keyed by
- * `StorageSourceDefinition.key`. Collection properties reference
- * a source by key via `StorageConfig.storageSource`.
- *
- * Typical bootstrap flow:
- * 1. Fetch definitions from `GET /api/storage/sources`
- * 2. Build server-backed sources automatically via `createStorage(transport, key)`
- * 3. Register "direct" sources manually (e.g. Firebase Storage hook)
- */
-
-import type { StorageSource, StorageSourceRegistry, StorageSourceDefinition } from "@rebasepro/types";
-import { DEFAULT_STORAGE_SOURCE_KEY } from "@rebasepro/types";
-import { createStorage } from "./storage";
-import type { Transport } from "./transport";
-
-/**
- * Default implementation of the client-side `StorageSourceRegistry`.
- */
-export class ClientStorageSourceRegistry implements StorageSourceRegistry {
-    private sources = new Map<string, StorageSource>();
-
-    /**
-     * Register a storage source.
-     * @param key - Unique key matching a `StorageSourceDefinition.key`
-     * @param source - The `StorageSource` instance
-     */
-    register(key: string, source: StorageSource): void {
-        this.sources.set(key, source);
-    }
-
-    getDefault(): StorageSource {
-        const source = this.sources.get(DEFAULT_STORAGE_SOURCE_KEY);
-        if (!source) {
-            throw new Error(
-                `[StorageSourceRegistry] No default storage source registered. ` +
-                `Register one with key "${DEFAULT_STORAGE_SOURCE_KEY}".`
-            );
-        }
-        return source;
-    }
-
-    get(key: string | undefined | null): StorageSource | undefined {
-        if (key === undefined || key === null) {
-            return this.sources.get(DEFAULT_STORAGE_SOURCE_KEY);
-        }
-        return this.sources.get(key);
-    }
-
-    getOrDefault(key: string | undefined | null): StorageSource {
-        if (key === undefined || key === null) {
-            return this.getDefault();
-        }
-        const source = this.sources.get(key);
-        if (source) return source;
-
-        // Fallback to default
-        console.warn(
-            `[StorageSourceRegistry] Storage source "${key}" not found, ` +
-            `falling back to "${DEFAULT_STORAGE_SOURCE_KEY}".`
-        );
-        return this.getDefault();
-    }
-
-    has(key: string): boolean {
-        return this.sources.has(key);
-    }
-
-    list(): string[] {
-        return Array.from(this.sources.keys());
-    }
-
-    /**
-     * Build a registry from `StorageSourceDefinition[]` and an HTTP transport.
-     *
-     * - Sources with `transport: "server"` are auto-wired via `createStorage(transport, key)`.
-     * - Sources with `transport: "direct"` are **not** auto-wired — they must
-     *   be registered manually after this call (e.g. via a Firebase hook).
-     *
-     * @param definitions - Array of storage source definitions
-     * @param transport - HTTP transport for server-backed sources
-     */
-    static fromDefinitions(
-        definitions: StorageSourceDefinition[],
-        transport: Transport
-    ): ClientStorageSourceRegistry {
-        const registry = new ClientStorageSourceRegistry();
-
-        for (const def of definitions) {
-            if (def.transport === "server") {
-                // Auto-create a server-backed StorageSource for this key
-                const source = createStorage(transport, def.key === DEFAULT_STORAGE_SOURCE_KEY ? undefined : def.key);
-                registry.register(def.key, source);
-            }
-            // "direct" sources must be registered manually
-        }
-
-        return registry;
-    }
-}