@layers/amba-web 4.0.2 → 4.0.4

package/dist/index.js

@@ -99,8 +99,173 @@ function toAmbaApiError(err) {
 	return new AmbaApiError("UNKNOWN_ERROR", String(err));
 }
 
+//#endregion
+//#region src/realtime.ts
+const INITIAL_BACKOFF_MS = 500;
+const MAX_BACKOFF_MS = 15e3;
+/**
+* Builder returned by `Amba.collection(name)`. Chain `.where(...)` to
+* narrow, then `.subscribe(cb)` to start streaming.
+*/
+var CollectionSubscription = class {
+	filters = {};
+	constructor(ctx, name) {
+		this.ctx = ctx;
+		this.name = name;
+	}
+	/** Add an equality filter. Chainable. All filters must match (AND). */
+	where(column, value) {
+		this.filters[column] = value;
+		return this;
+	}
+	/**
+	* Start listening. `cb` fires once per matching row change. Returns an
+	* unsubscribe handle — call it to close the connection.
+	*/
+	subscribe(cb, options = {}) {
+		if (!this.ctx.authHeaders()) throw new Error("Amba.collection().subscribe() requires an authenticated session — call Amba.auth.signIn*/verify* first.");
+		const qs = Object.keys(this.filters).length > 0 ? `?where=${encodeURIComponent(JSON.stringify(this.filters))}` : "";
+		return openStream({
+			url: `${this.ctx.baseUrl}/v1/client/realtime/collections/${encodeURIComponent(this.name)}${qs}`,
+			authHeaders: this.ctx.authHeaders,
+			onChange: cb,
+			options
+		});
+	}
+};
+/**
+* Open a streamed GET to a realtime endpoint and dispatch row-change events
+* to `onChange`. Reconnects with exponential backoff until the returned
+* unsubscribe handle is invoked. Shared by both collection and conversation
+* subscriptions — the only thing that differs between them is the URL.
+*
+* Uses `fetch` + a streamed response body (rather than the browser's
+* native `EventSource`) because `EventSource` cannot set request headers —
+* which would force the session token into the URL query string, where it
+* would leak into access logs. Streaming `fetch` keeps auth in headers.
+*/
+function openStream(args) {
+	let stopped = false;
+	let controller = null;
+	let backoff = INITIAL_BACKOFF_MS;
+	const run = async () => {
+		while (!stopped) {
+			controller = new AbortController();
+			try {
+				const headers = args.authHeaders();
+				if (!headers) throw new Error("no active session");
+				const resp = await fetch(args.url, {
+					method: "GET",
+					headers: {
+						...headers,
+						Accept: "text/event-stream"
+					},
+					signal: controller.signal
+				});
+				if (!resp.ok || !resp.body) throw new Error(`realtime connect failed: HTTP ${resp.status}`);
+				await consume(resp.body, args, () => {
+					backoff = INITIAL_BACKOFF_MS;
+					args.options.onOpen?.();
+				});
+			} catch (err) {
+				if (stopped) break;
+				args.options.onError?.(err);
+			}
+			if (stopped) break;
+			await delay(backoff);
+			backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+		}
+	};
+	run();
+	return () => {
+		stopped = true;
+		controller?.abort();
+	};
+}
+async function consume(body, args, onFirstFrame) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let sawFrame = false;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) return;
+		buffer += decoder.decode(value, { stream: true });
+		let idx;
+		while ((idx = buffer.indexOf("\n\n")) !== -1) {
+			const frame = buffer.slice(0, idx);
+			buffer = buffer.slice(idx + 2);
+			if (!sawFrame) {
+				sawFrame = true;
+				onFirstFrame();
+			}
+			dispatchFrame(frame, args.onChange);
+		}
+	}
+}
+function dispatchFrame(frame, onChange) {
+	let event = "";
+	const dataLines = [];
+	for (const line of frame.split("\n")) {
+		if (line.startsWith(":")) continue;
+		if (line.startsWith("event:")) event = line.slice(6).trim();
+		else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+	}
+	if (event !== "change") return;
+	try {
+		const payload = JSON.parse(dataLines.join("\n"));
+		onChange({
+			op: payload.op,
+			row: payload.row,
+			truncated: payload.truncated
+		});
+	} catch {}
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Builder returned by `Amba.messaging.conversation(id)`. Call `.subscribe(cb)`
+* to receive new messages live instead of polling.
+*
+*   const unsub = Amba.messaging
+*     .conversation(conversationId)
+*     .subscribe((change) => {
+*       // change.op === "INSERT"; change.row is the new message
+*     });
+*   unsub(); // stop listening
+*
+* Delivery is scoped to conversation participants — you receive messages for
+* a conversation only if your session is a member of it. Reconnects with the
+* same exponential backoff as collection subscriptions.
+*/
+var ConversationSubscription = class {
+	constructor(ctx, conversationId) {
+		this.ctx = ctx;
+		this.conversationId = conversationId;
+	}
+	subscribe(cb, options = {}) {
+		if (!this.ctx.authHeaders()) throw new Error("Amba.messaging.conversation().subscribe() requires an authenticated session — call Amba.auth.signIn*/verify* first.");
+		return openStream({
+			url: `${this.ctx.baseUrl}/v1/client/realtime/conversations/${encodeURIComponent(this.conversationId)}`,
+			authHeaders: this.ctx.authHeaders,
+			onChange: cb,
+			options
+		});
+	}
+};
+
 //#endregion
 //#region src/index.ts
+const DEFAULT_API_URL = "https://api.amba.dev";
+/**
+* Default host that serves deployed functions. `Amba.functions.invoke(name)`
+* targets `https://<projectId>.<DEFAULT_FUNCTIONS_HOST>/<name>` unless a
+* `functionsBaseUrl` override is configured. The `<projectId>` label is the
+* server-resolved id (from `diagnostics.ping`), which the function router
+* accepts directly.
+*/
+const DEFAULT_FUNCTIONS_HOST = "fn.amba.host";
 /**
 * Internal state — one instance per page. Created lazily by `Amba.configure()`.
 */
@@ -111,6 +276,26 @@ let coreInstance = null;
 * core finishes initializing.
 */
 let _configuredProjectId = null;
+/**
+* Realtime (`Amba.collection(name).subscribe`) needs the API base URL,
+* client key, and current session token in the TS layer to open the
+* streamed connection — the engine doesn't expose them back. We capture
+* the base URL + client key at configure-time and the session token from
+* every auth result (the engine rotates it internally on refresh; the
+* subscribe connection picks up the latest at connect time).
+*/
+let _configuredApiUrl = DEFAULT_API_URL;
+let _configuredClientKey = null;
+let _currentSessionToken = null;
+/**
+* Functions invocation state. `_configuredFunctionsBaseUrl` is the optional
+* override from `Amba.configure({ functionsBaseUrl })`. When it's null, the
+* default-host path resolves the project id once via `diagnostics.ping` and
+* caches it in `_resolvedFunctionsProjectId` so subsequent invokes skip the
+* round-trip. Both reset on every `configure()`.
+*/
+let _configuredFunctionsBaseUrl = null;
+let _resolvedFunctionsProjectId = null;
 function requireCore() {
 	if (!coreInstance) throw new AmbaApiError("NOT_INITIALIZED", "amba SDK not configured. Call Amba.configure({ projectId, clientKey }) at app start before any other API.");
 	return coreInstance;
@@ -148,9 +333,40 @@ function notifyAuthSubscribers(session) {
 	}
 }
 async function notifyFromAuthResult(result) {
+	if (result?.session_token) _currentSessionToken = result.session_token;
 	notifyAuthSubscribers(snapshotSession(result.user));
 }
 /**
+* Build the auth headers for a realtime subscribe connection, or `null`
+* when there's no live session. Read lazily at connect-time so reconnects
+* pick up a rotated session token.
+*/
+function realtimeAuthHeaders() {
+	if (!_configuredClientKey || !_currentSessionToken) return null;
+	return {
+		"X-Api-Key": _configuredClientKey,
+		Authorization: `Bearer ${_currentSessionToken}`
+	};
+}
+/**
+* Resolve the full invocation URL for a deployed function.
+*
+* With `functionsBaseUrl` configured we POST to `<base>/<name>` verbatim
+* (custom domains / non-prod). Otherwise we resolve the server-side project
+* id once (via `diagnostics.ping`, cached) and target
+* `https://<projectId>.fn.amba.host/<name>` — the function router accepts the
+* project id as the host label directly.
+*/
+async function resolveFunctionUrl(name) {
+	if (_configuredFunctionsBaseUrl) return `${_configuredFunctionsBaseUrl.replace(/\/$/, "")}/${encodeURIComponent(name)}`;
+	if (!_resolvedFunctionsProjectId) {
+		const ping = await Amba.diagnostics.ping();
+		if (!ping.ok || !ping.server_project_id) throw new AmbaApiError("FUNCTIONS_HOST_UNRESOLVED", "Could not resolve the functions host for this project. Pass `functionsBaseUrl` to Amba.configure() to invoke functions explicitly.", ping);
+		_resolvedFunctionsProjectId = ping.server_project_id;
+	}
+	return `https://${_resolvedFunctionsProjectId}.${DEFAULT_FUNCTIONS_HOST}/${encodeURIComponent(name)}`;
+}
+/**
 * Top-level SDK namespace.
 *
 * Stateless from the JS side — all state lives in the SDK runtime. Calling
@@ -187,6 +403,10 @@ const Amba = {
 			throw toAmbaApiError(err);
 		}
 		_configuredProjectId = config.projectId;
+		_configuredApiUrl = config.apiUrl ?? DEFAULT_API_URL;
+		_configuredClientKey = config.clientKey;
+		_configuredFunctionsBaseUrl = config.functionsBaseUrl ?? null;
+		_resolvedFunctionsProjectId = null;
 	},
 	get projectId() {
 		if (!_configuredProjectId) throw new AmbaApiError("NOT_INITIALIZED", "amba SDK not configured. Call Amba.configure({ projectId, clientKey }) at app start before any other API.");
@@ -268,6 +488,9 @@ const Amba = {
 		linkEmailOtp: async (email, code) => {
 			return await coreCall((c) => c.linkEmailOtp(email, code));
 		},
+		linkEmailPassword: async (email, password) => {
+			return await coreCall((c) => c.linkEmailPassword(email, password));
+		},
 		unlinkSmsOtp: async () => {
 			return await coreCall((c) => c.unlinkSmsOtp());
 		},
@@ -285,6 +508,7 @@ const Amba = {
 		},
 		signOut: async (rotateAnonymousId = false) => {
 			await coreCall((c) => c.signOut(rotateAnonymousId));
+			_currentSessionToken = null;
 			notifyAuthSubscribers(null);
 		},
 		refresh: async () => {
@@ -328,6 +552,10 @@ const Amba = {
 			await coreCall((c) => c.sessionsRevoke(sessionId));
 		}
 	},
+	collection: (name) => new CollectionSubscription({
+		baseUrl: _configuredApiUrl,
+		authHeaders: realtimeAuthHeaders
+	}, name),
 	collections: {
 		find: async (name, options = {}) => {
 			return await coreCall((c) => c.collectionsFind(name, encodeJson(options)));
@@ -485,6 +713,45 @@ const Amba = {
 	ai: { anthropic: { messages: { create: async (request) => {
 		return await coreCall((c) => c.aiAnthropicMessages(encodeJson(request)));
 	} } } },
+	functions: { invoke: async (name, body, options) => {
+		requireCore();
+		if (!_configuredClientKey) throw new AmbaApiError("NOT_INITIALIZED", "amba SDK not configured. Call Amba.configure({ projectId, clientKey }) before Amba.functions.invoke().");
+		if (!name || name.trim() === "") throw new AmbaApiError("INVALID_ARGUMENT", "Amba.functions.invoke: a function name is required.");
+		const url = await resolveFunctionUrl(name);
+		const method = options?.method ?? "POST";
+		const headers = {
+			"X-Api-Key": _configuredClientKey,
+			...options?.headers ?? {}
+		};
+		if (_currentSessionToken) headers["Authorization"] = `Bearer ${_currentSessionToken}`;
+		let requestBody;
+		if (body !== void 0 && method !== "GET") {
+			headers["content-type"] = "application/json";
+			requestBody = JSON.stringify(body);
+		}
+		let resp;
+		try {
+			resp = await fetch(url, {
+				method,
+				headers,
+				body: requestBody
+			});
+		} catch (err) {
+			throw new AmbaApiError("NETWORK_ERROR", `Amba.functions.invoke("${name}") network error: ${String(err)}`);
+		}
+		const text = await resp.text();
+		let parsed = void 0;
+		if (text.length > 0) try {
+			parsed = JSON.parse(text);
+		} catch {
+			parsed = text;
+		}
+		if (!resp.ok) {
+			const envelope = parsed && typeof parsed === "object" ? parsed : void 0;
+			throw new AmbaApiError(typeof envelope?.error?.code === "string" ? envelope.error.code : `HTTP_${resp.status}`, typeof envelope?.error?.message === "string" ? envelope.error.message : typeof parsed === "string" && parsed.length > 0 ? parsed : `Amba.functions.invoke("${name}") failed with status ${resp.status}`, parsed);
+		}
+		return parsed;
+	} },
 	config: { fetch: async () => {
 		return await coreCall((c) => c.configFetch());
 	} },
@@ -591,7 +858,12 @@ const Amba = {
 		getMessage: async (conversationId, messageId) => {
 			return await coreCall((c) => c.messagingGetMessage(conversationId, messageId));
 		},
-		markRead: async (conversationId) => await coreCall((c) => c.messagingMarkRead(conversationId))
+		addParticipant: async (conversationId, userId) => await coreCall((c) => c.messagingAddParticipant(conversationId, userId)),
+		markRead: async (conversationId) => await coreCall((c) => c.messagingMarkRead(conversationId)),
+		conversation: (conversationId) => new ConversationSubscription({
+			baseUrl: _configuredApiUrl,
+			authHeaders: realtimeAuthHeaders
+		}, conversationId)
 	},
 	moderation: {
 		reportUser: async (request) => await coreCall((c) => c.moderationReportUser(encodeJson(request))),
@@ -649,8 +921,8 @@ function getCoreWasm() {
 * `verify-sdk-version-coherence` GH action gates every publish on the
 * pair agreeing (and matching the `web-v<X.Y.Z>` tag when tag-triggered).
 */
-const SDK_VERSION = "4.0.2";
+const SDK_VERSION = "4.0.4";
 
 //#endregion
-export { Amba, AmbaApiError, SDK_VERSION, getCoreWasm };
+export { Amba, AmbaApiError, CollectionSubscription, ConversationSubscription, SDK_VERSION, getCoreWasm };
 //# sourceMappingURL=index.js.map