@rebasepro/client 0.6.1 → 0.8.0

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("&") : "";
 }
@@ -583,6 +525,31 @@ function createAuth(transport, options) {
 		if (!res.ok) throwApiError(res.status, body, res.statusText);
 		return body;
 	}
+	async function sendMagicLink(email) {
+		const res = await getFetch()(authUrl("/magic-link"), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ email })
+		});
+		const body = await res.json().catch(() => ({}));
+		if (!res.ok) throwApiError(res.status, body, res.statusText);
+		return body;
+	}
+	async function verifyMagicLink(token) {
+		const res = await getFetch()(authUrl("/magic-link/verify"), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ token })
+		});
+		const body = await res.json().catch(() => ({}));
+		if (!res.ok) throwApiError(res.status, body, res.statusText);
+		const session = handleAuthResponse(body, "SIGNED_IN");
+		return {
+			user: session.user,
+			accessToken: session.accessToken,
+			refreshToken: session.refreshToken
+		};
+	}
 	async function getSessions() {
 		return (await transport.request(authPath + "/sessions", { method: "GET" })).sessions;
 	}
@@ -659,6 +626,8 @@ function createAuth(transport, options) {
 		changePassword,
 		sendVerificationEmail,
 		verifyEmail,
+		sendMagicLink,
+		verifyMagicLink,
 		getSessions,
 		revokeSession,
 		revokeAllSessions,
@@ -739,6 +708,15 @@ function createAdmin(transport, options) {
 	async function deleteUser(userId) {
 		return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "DELETE" });
 	}
+	async function resetPassword(userId, options) {
+		return transport.request(adminPath + "/users/" + encodeURIComponent(userId) + "/reset-password", {
+			method: "POST",
+			...options?.password ? { body: JSON.stringify({ password: options.password }) } : {}
+		});
+	}
+	async function listRoles() {
+		return transport.request(adminPath + "/roles", { method: "GET" });
+	}
 	async function bootstrap() {
 		return transport.request(adminPath + "/bootstrap", { method: "POST" });
 	}
@@ -749,6 +727,8 @@ function createAdmin(transport, options) {
 		createUser,
 		updateUser,
 		deleteUser,
+		resetPassword,
+		listRoles,
 		bootstrap
 	};
 }
@@ -786,95 +766,51 @@ function createCron(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];
+//#region src/api-keys.ts
+/**
+* Creates a client for managing API keys via the admin routes.
+*
+* @param transport - The shared HTTP transport created by `createTransport`.
+* @param options   - Optional overrides (e.g. a custom base path).
+*/
+function createApiKeys(transport, options) {
+	const apiKeysPath = options?.apiKeysPath || "/admin/api-keys";
+	/** List all API keys (masked). */
+	async function listKeys() {
+		return transport.request(apiKeysPath, { method: "GET" });
+	}
+	/** Get a single API key by ID (masked). */
+	async function getKey(id) {
+		return transport.request(apiKeysPath + "/" + encodeURIComponent(id), { method: "GET" });
+	}
+	/** Create a new API key. The full secret is included in the response. */
+	async function createKey(data) {
+		return transport.request(apiKeysPath, {
+			method: "POST",
+			body: JSON.stringify(data)
+		});
+	}
+	/** Update an existing API key. */
+	async function updateKey(id, data) {
+		return transport.request(apiKeysPath + "/" + encodeURIComponent(id), {
+			method: "PUT",
+			body: JSON.stringify(data)
+		});
+	}
+	/** Revoke (soft-delete) an API key. */
+	async function revokeKey(id) {
+		return transport.request(apiKeysPath + "/" + encodeURIComponent(id), { method: "DELETE" });
+	}
+	return {
+		listKeys,
+		getKey,
+		createKey,
+		updateKey,
+		revokeKey
 	};
-	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;
 }
+//#endregion
+//#region src/collection.ts
 /**
 * Wrap a flat row (returned by the REST API as `{ id, ...fields }`) into
 * a proper `Entity<M>` structure expected by the core framework.
@@ -939,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);
@@ -957,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({
@@ -1016,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: {}
@@ -1037,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);
@@ -1063,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");
@@ -1076,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;
 		}
@@ -1092,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 {
@@ -1103,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.
@@ -2037,8 +2063,26 @@ function createRebaseClient(options) {
 	const auth = createAuth(transport, options.auth);
 	const admin = createAdmin(transport, options.admin);
 	const cron = createCron(transport, options.cron);
+	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) {
@@ -2084,14 +2128,21 @@ 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,
 		admin,
 		cron,
+		apiKeys,
 		functions,
 		storage,
+		storageRegistry,
+		createStorageSource,
+		fetchStorageSources,
 		ws,
 		setToken: transport.setToken,
 		setAuthTokenGetter: transport.setAuthTokenGetter,
@@ -2112,6 +2163,6 @@ function createRebaseClient(options) {
 	};
 }
 //#endregion
-export { ApiError, QueryBuilder, RebaseApiError, RebaseWebSocketClient, and, buildQueryString, cond, createAdmin, 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