experimental-a2 0.2.0 → 0.3.0

package/dist/log-redis-http.d.ts

@@ -0,0 +1,21 @@
+import { c as IdSource, i as Clock, t as A2Log } from "./log-ldf5g8Cx.js";
+//#region src/log-redis-http.d.ts
+type RedisHttpLogOptions = {
+  /** REST endpoint, e.g. `process.env.UPSTASH_REDIS_REST_URL`. */
+  url: string;
+  /** Bearer token, e.g. `process.env.UPSTASH_REDIS_REST_TOKEN`. */
+  token: string;
+  /** Key prefix — isolates multiple apps on one Redis. Default `'a2'`. */
+  keyPrefix?: string;
+  /** Injectable clock — every stored timestamp comes from here. */
+  clock?: Clock;
+  /** Injectable id source for generated event ids. */
+  ids?: IdSource;
+};
+type RedisHttpLog = A2Log & {
+  /** Nothing to disconnect; present so callers can treat logs uniformly. */
+  close(): Promise<void>;
+};
+declare function redisHttp(options: RedisHttpLogOptions): RedisHttpLog;
+//#endregion
+export { RedisHttpLog, RedisHttpLogOptions, redisHttp };

package/dist/log-redis-http.js

@@ -0,0 +1,62 @@
+import { t as A2Error } from "./errors-BJRMd-h6.js";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
+import { n as pollingStream } from "./log-polling-DZ1MiKLg.js";
+import { t as createRedisLogCore } from "./log-redis-core-CyJ5L8yR.js";
+//#region src/log-redis-http.ts
+/**
+* experimental-a2/log-redis-http — the same Redis Streams log over a
+* provider REST API (Upstash-shaped: POST one command as a JSON array,
+* receive `{ result }` or `{ error }`). The storage semantics live in
+* log-redis-core.ts, shared with experimental-a2/log-redis.
+*
+* Fully connectionless: every command is one `fetch`, so it works
+* where a Redis-protocol connection cannot exist or cannot be spared.
+* Without a connection there is no push and no pub/sub, so `stream()`
+* is the shared activity-adaptive poll loop (25ms while events flow,
+* backing off to a 250ms idle ceiling). No peer dependencies.
+*/
+function redisHttp(options) {
+	if (!options.url || !options.token) throw new TypeError("redisHttp() needs a url and a token");
+	const { url, token } = options;
+	const call = async (command, ...args) => {
+		let response;
+		try {
+			response = await fetch(url, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${token}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify([command, ...args.map(String)])
+			});
+		} catch (err) {
+			throw new A2Error("LOG_UNAVAILABLE", "redis rest request failed", { cause: err });
+		}
+		const body = await response.json().catch(() => null);
+		if (body === null || !response.ok || body.error !== void 0) throw new A2Error("LOG_UNAVAILABLE", `redis rest command failed: ${body?.error ?? `status ${response.status}`}`);
+		return body.result;
+	};
+	const core = createRedisLogCore({
+		call,
+		clock: options.clock ?? SYSTEM_CLOCK,
+		ids: options.ids ?? RANDOM_IDS,
+		keyPrefix: options.keyPrefix ?? "a2"
+	});
+	return {
+		append: core.append,
+		read: core.read,
+		claimAvailable: core.claimAvailable,
+		renewClaims: core.renewClaims,
+		completeAttempt: core.completeAttempt,
+		failAttempt: core.failAttempt,
+		readState: core.readState,
+		putSnapshot: core.putSnapshot,
+		inspect: core.inspect,
+		stream(sessionId, opts) {
+			return pollingStream((afterIndex) => core.readRange(sessionId, afterIndex), opts?.startAt !== void 0 ? { startAt: opts.startAt } : {});
+		},
+		async close() {}
+	};
+}
+//#endregion
+export { redisHttp };

package/dist/log-redis.d.ts

@@ -2,18 +2,24 @@ import { c as IdSource, i as Clock, t as A2Log } from "./log-ldf5g8Cx.js";
 //#region src/log-redis.d.ts
 /**
  * The minimal client this backend needs — `ioredis` matches it
- * structurally. `call` issues any command; `duplicate` opens the
- * dedicated connection each blocking live feed holds.
+ * structurally. `call` issues any command; `duplicate` opens the one
+ * shared subscriber connection; `on` delivers its pub/sub messages.
+ *
+ * The client must restore its subscriptions after a reconnect
+ * (`ioredis` does). One that doesn't stays correct — the safety
+ * re-read delivers everything — but every live feed silently degrades
+ * to safety-read latency from that point on.
  */
 type RedisConnection = {
   call(command: string, ...args: Array<string | number>): Promise<unknown>;
   duplicate(): RedisConnection;
+  on(event: "message", listener: (channel: string, message: string) => void): unknown;
   disconnect(): void;
 };
 type RedisLogOptions = {
   /** Creates an `ioredis` client lazily (optional peer dep `ioredis`). */
   url?: string | undefined;
-  /** Bring your own client — anything `call`/`duplicate`/`disconnect`. */
+  /** Bring your own client — anything `call`/`duplicate`/`on`/`disconnect`. */
   client?: RedisConnection;
   /** Key prefix — isolates multiple apps on one Redis. Default `'a2'`. */
   keyPrefix?: string;
@@ -23,7 +29,7 @@ type RedisLogOptions = {
   ids?: IdSource;
 };
 type RedisLog = A2Log & {
-  /** Disconnect the client and every live stream connection. */
+  /** Disconnect the command client and the shared subscriber. */
   close(): Promise<void>;
 };
 declare function redis(options?: RedisLogOptions): RedisLog;