@rebasepro/client 0.7.0 → 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rebase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/api-keys.d.ts

@@ -10,6 +10,7 @@ export interface ApiKeyMasked {
     name: string;
     key_prefix: string;
     permissions: ApiKeyPermission[];
+    admin: boolean;
     rate_limit: number | null;
     created_by: string;
     created_at: string;

package/dist/collection.d.ts

@@ -1,6 +1,6 @@
 import { FindParams, Transport } from "./transport";
 import { RebaseWebSocketClient } from "./websocket";
-import { CollectionAccessor, FilterOperator, LogicalCondition, WhereValue } from "@rebasepro/types";
+import { CollectionAccessor, LogicalCondition, WhereFilterOp, WhereValue } from "@rebasepro/types";
 import { QueryBuilder } from "./query_builder";
 /**
  * CollectionClient extends `CollectionAccessor` from `@rebasepro/types` so that
@@ -9,9 +9,9 @@ import { QueryBuilder } from "./query_builder";
  * Additionally it exposes fluent query builder methods like `.where()`, `.orderBy()`.
  */
 export interface CollectionClient<M extends Record<string, unknown> = Record<string, unknown>> extends CollectionAccessor<M> {
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): QueryBuilder<M>;
+    where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): QueryBuilder<M>;
     where(logicalCondition: LogicalCondition): QueryBuilder<M>;
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilder<M>;
+    orderBy(column: keyof M & string, direction?: "asc" | "desc"): QueryBuilder<M>;
     limit(count: number): QueryBuilder<M>;
     offset(count: number): QueryBuilder<M>;
     search(searchString: string): QueryBuilder<M>;

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { createApiKeys, CreateApiKeysOptions } from "./api-keys";
 import { CollectionClient } from "./collection";
 import { createFunctionsClient } from "./functions";
 import { RebaseWebSocketClient } from "./websocket";
-import { RebaseClient, RebaseData, StorageSource } from "@rebasepro/types";
+import { RebaseClient, RebaseData, StorageSource, StorageSourceDefinition, StorageSourceRegistry } from "@rebasepro/types";
 export * from "./transport";
 export * from "./auth";
 export * from "./admin";
@@ -16,6 +16,7 @@ export * from "./collection";
 export * from "./query_builder";
 export * from "./websocket";
 export * from "./storage";
+export * from "./storage-registry";
 export * from "./reviver";
 export * from "./functions";
 export type { Entity, FindResponse } from "@rebasepro/types";
@@ -24,6 +25,21 @@ export interface CreateRebaseClientOptions extends RebaseClientConfig {
     admin?: CreateAdminOptions;
     cron?: CreateCronOptions;
     apiKeys?: CreateApiKeysOptions;
+    /**
+     * Declared storage sources for multi-backend support. Server-transport
+     * entries are auto-wired into `client.storageRegistry`; `direct` sources
+     * are registered app-side (e.g. via a Firebase Storage hook). The default
+     * source (`storage`) is always registered under
+     * {@link DEFAULT_STORAGE_SOURCE_KEY}.
+     */
+    storageSources?: StorageSourceDefinition[];
+    /**
+     * Maps camelCase property names / safe identifiers to the actual
+     * collection slugs on the server (e.g. `{ companyMembers: "company-members" }`).
+     * If provided, the data layer proxy will resolve property accessors to their
+     * correct slugs via this map before falling back to automatic snake_casing.
+     */
+    collections?: Record<string, string>;
 }
 type KebabToCamelCase<S extends string> = S extends `${infer T}-${infer U}` ? `${T}${Capitalize<KebabToCamelCase<U>>}` : S;
 type TypedDataLayer<DB> = {
@@ -54,6 +70,9 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
     functions: ReturnType<typeof createFunctionsClient>;
     ws?: RebaseWebSocketClient;
     storage: StorageSource;
+    storageRegistry: StorageSourceRegistry;
+    createStorageSource: (storageId: string) => StorageSource;
+    fetchStorageSources: () => Promise<StorageSourceDefinition[]>;
     call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
     data: TypedDataLayer<DB>;
 };

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { EntityReference, EntityRelation, GeoPoint, Vector } from "@rebasepro/types";
-import { QueryBuilder, and, cond, or } from "@rebasepro/common";
+import { QueryBuilder, and, cond, or, serializeFilter, serializeLogicalCondition } from "@rebasepro/common";
+import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, Vector } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 //#region src/reviver.ts
 function rebaseReviver(_key, value) {
@@ -42,61 +42,6 @@ var RebaseApiError = class extends Error {
 		this.details = details;
 	}
 };
-/**
-* Maps a short operator alias to the PostgREST-style short code.
-*/
-var OP_MAP = {
-	"==": "eq",
-	"!=": "neq",
-	">": "gt",
-	">=": "gte",
-	"<": "lt",
-	"<=": "lte",
-	"not-in": "nin",
-	"array-contains": "cs",
-	"array-contains-any": "csa"
-};
-/**
-* Normalise a single `WhereFieldValue` into the PostgREST query-string
-* representation the backend expects.
-*
-* Supports:
-*  - `null`          → `"eq.null"`
-*  - `true`/`false`  → `"eq.true"` / `"eq.false"`
-*  - `42`            → `"42"` (plain equality)
-*  - `"active"`      → `"active"` (plain equality, backward-compat)
-*  - `"gte.18"`      → `"gte.18"` (pass-through PostgREST string)
-*  - `[">=", 18]`    → `"gte.18"` (tuple syntax)
-*  - `["in", [1,2]]` → `"in.(1,2)"` (tuple with array value)
-*  - `["!=", null]`  → `"neq.null"`
-*/
-function normalizeWhereValue(value) {
-	if (value === null) return "eq.null";
-	if (typeof value === "boolean") return `eq.${value}`;
-	if (typeof value === "number") return String(value);
-	if (Array.isArray(value)) {
-		const [rawOp, val] = (Array.isArray(value[0]) ? value : [value])[0] || [];
-		if (rawOp) {
-			const op = OP_MAP[rawOp] ?? rawOp;
-			if (val === null) return `${op}.null`;
-			if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
-			return `${op}.${val}`;
-		}
-	}
-	return String(value);
-}
-function serializeLogicalCondition(cond) {
-	if ("type" in cond) {
-		const sub = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
-		return `${cond.type}(${sub})`;
-	} else {
-		const op = OP_MAP[cond.operator] ?? cond.operator;
-		let formattedValue = cond.value;
-		if (Array.isArray(cond.value)) formattedValue = `(${cond.value.join(",")})`;
-		else if (cond.value === null) formattedValue = "null";
-		return `${cond.column}.${op}.${formattedValue}`;
-	}
-}
 function buildQueryString(params) {
 	if (!params) return "";
 	const parts = [];
@@ -111,13 +56,10 @@ function buildQueryString(params) {
 		const serialized = (root.conditions ?? []).map(serializeLogicalCondition).join(",");
 		parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
 	}
-	if (params.where) for (const [field, value] of Object.entries(params.where)) if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) for (const subVal of value) {
-		const normalized = normalizeWhereValue(subVal);
-		parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
-	}
-	else {
-		const normalized = normalizeWhereValue(value);
-		parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+	if (params.where) {
+		const serialized = serializeFilter(params.where);
+		for (const [field, value] of Object.entries(serialized)) if (Array.isArray(value)) for (const v of value) parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(v)}`);
+		else parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(value)}`);
 	}
 	return parts.length > 0 ? "?" + parts.join("&") : "";
 }
@@ -869,94 +811,6 @@ function createApiKeys(transport, options) {
 }
 //#endregion
 //#region src/collection.ts
-function parseWhereFilter(where) {
-	if (!where) return void 0;
-	const filters = {};
-	const OP_TO_FILTER = {
-		"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"
-	};
-	const parseSingle = (rawValue, fieldKey) => {
-		if (rawValue === null) return ["==", null];
-		if (typeof rawValue === "boolean") return ["==", rawValue];
-		if (typeof rawValue === "number") return ["==", rawValue];
-		if (Array.isArray(rawValue) && rawValue.length === 2 && typeof rawValue[0] === "string") {
-			const [rawOp, val] = rawValue;
-			return [OP_TO_FILTER[rawOp] ?? "==", val];
-		}
-		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 = "==";
-			let val = 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;
-			}
-			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) && fieldKey !== "id" && !fieldKey.endsWith("_id")) val = Number(val);
-			return [op, val];
-		} else return ["==", value];
-	};
-	for (const [key, rawValue] of Object.entries(where)) if (Array.isArray(rawValue) && rawValue.length > 0 && Array.isArray(rawValue[0])) filters[key] = rawValue.map((r) => parseSingle(r, key));
-	else filters[key] = parseSingle(rawValue, key);
-	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.
@@ -1021,8 +875,8 @@ function createCollectionClient(transport, slug, ws) {
 			if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
 			return builder.where(columnOrCondition, operator, value);
 		},
-		orderBy(column, ascending) {
-			return new QueryBuilder(client).orderBy(column, ascending);
+		orderBy(column, direction) {
+			return new QueryBuilder(client).orderBy(column, direction);
 		},
 		limit(count) {
 			return new QueryBuilder(client).limit(count);
@@ -1039,26 +893,45 @@ function createCollectionClient(transport, slug, ws) {
 	};
 	if (ws) {
 		client.listen = (params, onUpdate, onError) => {
-			return ws.listenCollection({
+			let active = true;
+			let lastUpdateId = 0;
+			const unsub = ws.listenCollection({
 				path: slug,
-				filter: parseWhereFilter(params?.where),
+				filter: params?.where,
 				limit: params?.limit,
 				startAfter: params?.offset ? String(params.offset) : void 0,
 				orderBy: params?.orderBy?.split(":")[0],
 				order: params?.orderBy?.split(":")[1],
 				searchString: params?.searchString
 			}, (entities) => {
+				const currentUpdateId = ++lastUpdateId;
 				const requestedLimit = params?.limit || 20;
+				const offset = params?.offset || 0;
 				onUpdate({
 					data: entities,
 					meta: {
 						total: entities.length,
 						limit: requestedLimit,
-						offset: params?.offset || 0,
+						offset,
 						hasMore: entities.length >= requestedLimit
 					}
 				});
+				if (client.count) client.count(params).then((total) => {
+					if (active && currentUpdateId === lastUpdateId) onUpdate({
+						data: entities,
+						meta: {
+							total,
+							limit: requestedLimit,
+							offset,
+							hasMore: offset + entities.length < total
+						}
+					});
+				}).catch(() => {});
 			}, onError);
+			return () => {
+				active = false;
+				unsub();
+			};
 		};
 		client.listenById = (id, onUpdate, onError) => {
 			return ws.listenEntity({
@@ -1098,17 +971,31 @@ function createFunctionsClient(transport) {
 }
 //#endregion
 //#region src/storage.ts
-function createStorage(transport) {
+/**
+* Create a StorageSource that talks to the Rebase backend REST API.
+*
+* @param transport - HTTP transport instance
+* @param storageId - Optional storage-source key for multi-backend routing.
+*                    When set, it is forwarded to the server so the correct
+*                    `StorageController` is resolved from the registry.
+*/
+function createStorage(transport, storageId) {
 	const urlsCache = /* @__PURE__ */ new Map();
+	/** Append ?storageId=... to a path when multi-backend routing is active. */
+	const withStorageId = (path) => {
+		if (!storageId) return path;
+		return `${path}${path.includes("?") ? "&" : "?"}storageId=${encodeURIComponent(storageId)}`;
+	};
 	async function putObject({ file, key, metadata, bucket }) {
 		const formData = new FormData();
 		formData.append("file", file);
 		if (key) formData.append("key", key);
 		if (bucket) formData.append("bucket", bucket);
+		if (storageId) formData.append("storageId", storageId);
 		if (metadata) {
 			for (const [key, value] of Object.entries(metadata)) if (value !== void 0 && value !== null) formData.append(`metadata_${key}`, typeof value === "string" ? value : JSON.stringify(value));
 		}
-		return (await transport.request("/storage/upload", {
+		return (await transport.request(withStorageId("/storage/upload"), {
 			method: "POST",
 			body: formData,
 			headers: {}
@@ -1119,18 +1006,18 @@ function createStorage(transport) {
 		const cached = urlsCache.get(cacheKey);
 		if (cached) return cached;
 		let filePath = keyOrUrl;
-		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
+		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) 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(`/storage/metadata/${filePath}`);
+			const result = await transport.request(withStorageId(`/storage/metadata/${filePath}`));
 			const activeToken = await transport.resolveToken();
 			const tokenQuery = activeToken ? `?token=${activeToken}` : "";
 			const downloadConfig = {
-				url: `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`,
+				url: withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`),
 				metadata: result.data
 			};
 			urlsCache.set(cacheKey, downloadConfig);
@@ -1145,10 +1032,10 @@ function createStorage(transport) {
 	}
 	async function getObject(key, bucket) {
 		let filePath = key;
-		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
+		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
 		if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
 		if (!filePath || filePath.trim() === "" || filePath === "/") return null;
-		const url = `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`;
+		const url = withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`);
 		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");
@@ -1158,11 +1045,11 @@ function createStorage(transport) {
 	}
 	async function deleteObject(key, bucket) {
 		let filePath = key;
-		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
+		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) 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" });
+			await transport.request(withStorageId(`/storage/file/${filePath}`), { method: "DELETE" });
 		} catch (e) {
 			if (!(e instanceof Error && "status" in e && e.status === 404)) throw e;
 		}
@@ -1174,6 +1061,7 @@ function createStorage(transport) {
 		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);
+		if (storageId) params.set("storageId", storageId);
 		return (await transport.request(`/storage/list?${params.toString()}`)).data;
 	}
 	return {
@@ -1185,6 +1073,62 @@ function createStorage(transport) {
 	};
 }
 //#endregion
+//#region src/storage-registry.ts
+/**
+* Default implementation of the client-side `StorageSourceRegistry`.
+*/
+var ClientStorageSourceRegistry = class ClientStorageSourceRegistry {
+	sources = /* @__PURE__ */ new Map();
+	/**
+	* Register a storage source.
+	* @param key - Unique key matching a `StorageSourceDefinition.key`
+	* @param source - The `StorageSource` instance
+	*/
+	register(key, source) {
+		this.sources.set(key, source);
+	}
+	getDefault() {
+		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) {
+		if (key === void 0 || key === null) return this.sources.get(DEFAULT_STORAGE_SOURCE_KEY);
+		return this.sources.get(key);
+	}
+	getOrDefault(key) {
+		if (key === void 0 || key === null) return this.getDefault();
+		const source = this.sources.get(key);
+		if (source) return source;
+		console.warn(`[StorageSourceRegistry] Storage source "${key}" not found, falling back to "${DEFAULT_STORAGE_SOURCE_KEY}".`);
+		return this.getDefault();
+	}
+	has(key) {
+		return this.sources.has(key);
+	}
+	list() {
+		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, transport) {
+		const registry = new ClientStorageSourceRegistry();
+		for (const def of definitions) if (def.transport === "server") {
+			const source = createStorage(transport, def.key === DEFAULT_STORAGE_SOURCE_KEY ? void 0 : def.key);
+			registry.register(def.key, source);
+		}
+		return registry;
+	}
+};
+//#endregion
 //#region src/websocket.ts
 /**
 * Extract error message and code from a WebSocket message payload.
@@ -2122,6 +2066,23 @@ function createRebaseClient(options) {
 	const apiKeys = createApiKeys(transport, options.apiKeys);
 	const storage = createStorage(transport);
 	const functions = createFunctionsClient(transport);
+	const createStorageSource = (storageId) => storageId === DEFAULT_STORAGE_SOURCE_KEY ? storage : createStorage(transport, storageId);
+	const storageRegistry = new ClientStorageSourceRegistry();
+	storageRegistry.register(DEFAULT_STORAGE_SOURCE_KEY, storage);
+	for (const def of options.storageSources ?? []) if (def.transport === "server" && def.key !== DEFAULT_STORAGE_SOURCE_KEY) storageRegistry.register(def.key, createStorageSource(def.key));
+	let storageSourcesPromise;
+	const fetchStorageSources = () => {
+		if (storageSourcesPromise) return storageSourcesPromise;
+		storageSourcesPromise = transport.request("/storage/sources").then((res) => {
+			const defs = res.data ?? [];
+			for (const def of defs) if (def.transport === "server" && def.key !== DEFAULT_STORAGE_SOURCE_KEY && !storageRegistry.has(def.key)) storageRegistry.register(def.key, createStorageSource(def.key));
+			return defs;
+		}).catch((e) => {
+			storageSourcesPromise = void 0;
+			throw e;
+		});
+		return storageSourcesPromise;
+	};
 	const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
 	let ws;
 	if (resolvedWsUrl) {
@@ -2167,7 +2128,10 @@ function createRebaseClient(options) {
 	const dataProxy = new Proxy({ collection }, { get(_target, prop) {
 		if (prop === "collection") return collection;
 		if (typeof prop === "symbol") return void 0;
-		if (typeof prop === "string" && prop !== "then" && prop !== "toJSON" && prop !== "$$typeof") return collection(toSnakeCase(prop));
+		if (typeof prop === "string" && prop !== "then" && prop !== "toJSON" && prop !== "$$typeof") {
+			if (options.collections && prop in options.collections) return collection(options.collections[prop]);
+			return collection(toSnakeCase(prop));
+		}
 	} });
 	return {
 		auth,
@@ -2176,6 +2140,9 @@ function createRebaseClient(options) {
 		apiKeys,
 		functions,
 		storage,
+		storageRegistry,
+		createStorageSource,
+		fetchStorageSources,
 		ws,
 		setToken: transport.setToken,
 		setAuthTokenGetter: transport.setAuthTokenGetter,
@@ -2196,6 +2163,6 @@ function createRebaseClient(options) {
 	};
 }
 //#endregion
-export { ApiError, QueryBuilder, RebaseApiError, RebaseWebSocketClient, and, buildQueryString, cond, createAdmin, createApiKeys, createAuth, createCollectionClient, createCookieStorage, createCron, createFunctionsClient, createMemoryStorage, createRebaseClient, createStorage, createTransport, or, rebaseReviver };
+export { ApiError, ClientStorageSourceRegistry, QueryBuilder, RebaseApiError, RebaseWebSocketClient, and, buildQueryString, cond, createAdmin, createApiKeys, createAuth, createCollectionClient, createCookieStorage, createCron, createFunctionsClient, createMemoryStorage, createRebaseClient, createStorage, createTransport, or, rebaseReviver };
 
 //# sourceMappingURL=index.es.js.map