@ahoo-wang/wow-view-store 9.2.0-rc.0

package/dist/errors.d.ts

@@ -0,0 +1,102 @@
+import { BindingError, WowError } from '@ahoo-wang/wow-client';
+import { ViewStoreError, ViewStoreErrorCode } from '@ahoo-wang/wow-view-engine';
+/**
+ * The view store's own error codes, beside Wow's (`ErrorCodes` of
+ * `@ahoo-wang/wow-client`).
+ *
+ * Named apart from the engine's `ViewStoreErrorCode` (the port's six codes): these
+ * are the server's `errorCode` strings, which a `ViewStoreError` carries as
+ * `detail.code`. Mirrors `ViewStoreErrorCodes` in
+ * `view-store/wow-view-store-api/src/main/kotlin/me/ahoo/wow/viewstore/api/ViewStoreErrorCodes.kt`.
+ */
+export declare const WowViewStoreErrorCodes: Readonly<{
+    /** A write that is not a valid view or preferences write (HTTP 400). */
+    readonly VIEW_INVALID: "ViewInvalid";
+    /** The request carries no `CoSec-App-Id` (HTTP 400). */
+    readonly VIEW_APP_REQUIRED: "ViewAppRequired";
+    /** A system view is read-only (HTTP 403). */
+    readonly SYSTEM_VIEW_READ_ONLY: "SystemViewReadOnly";
+    /** The path's tenant or owner is missing, blank or invisible (HTTP 400). */
+    readonly VIEW_SCOPE_REQUIRED: "ViewScopeRequired";
+    /** The view store's event streams are closed to HTTP queries (HTTP 403). */
+    readonly VIEW_EVENT_STREAM_CLOSED: "ViewEventStreamClosed";
+}>;
+/**
+ * The binding error code a claim refusal names each shared dashboard with
+ * (`View.REFERENCED_BY_SHARED_DASHBOARD`): the board's id as `name`, its
+ * title as `msg`.
+ */
+export declare const REFERENCED_BY_SHARED_DASHBOARD = "referenced-by-shared-dashboard";
+/**
+ * A request that did not succeed, as the store reads it: the server's error,
+ * when the server answered with one, and the HTTP status, when a response
+ * came back at all.
+ */
+export declare class Failure {
+    /** What the request threw. */
+    readonly cause: unknown;
+    /** The server's error, read from the failed response. */
+    readonly wow?: WowError | undefined;
+    /** The status of the failed response; absent when none came back. */
+    readonly status?: number | undefined;
+    constructor(
+    /** What the request threw. */
+    cause: unknown, 
+    /** The server's error, read from the failed response. */
+    wow?: WowError | undefined, 
+    /** The status of the failed response; absent when none came back. */
+    status?: number | undefined);
+    /** The server's error code, if it answered with one. */
+    get errorCode(): string | undefined;
+    get bindingErrors(): readonly BindingError[];
+    /**
+     * The path variable the fetcher's interceptors never filled, when that is
+     * why the request was never sent: the host's set-up is wrong, not the
+     * network.
+     */
+    get unfilled(): string | undefined;
+    /**
+     * The port's code for it (see {@link portCodeOf}). A path variable the
+     * interceptors never filled is `INVALID`, as the server's own
+     * `ViewScopeRequired` is: the request is wrong as built and a retry sends
+     * the same — not `UNAVAILABLE`, which would offer one.
+     */
+    get code(): ViewStoreErrorCode;
+    /**
+     * Whether the server (or something in front of it) answered at all: a
+     * response came back. An `UNAVAILABLE` that was answered is the server's
+     * own error — a 5xx, a timeout it reported — and not the network.
+     */
+    get reached(): boolean;
+    get message(): string;
+    /**
+     * The port's error, holding what it was read from: the request's own
+     * failure as `cause`, the server's error code as `detail` (a host tells
+     * `ViewAppRequired` from `ViewInvalid` by it), and for `UNAVAILABLE`
+     * whether the server answered (`reachable`).
+     */
+    toStoreError(): ViewStoreError;
+    /** {@link toStoreError} with another code: the same failure, read further. */
+    held(): {
+        cause: unknown;
+        detail?: {
+            code: string;
+        };
+        reachable?: true;
+    };
+}
+/** Whether the request id of a write was used before. */
+export declare function isDuplicateRequest(failure: Failure): boolean;
+/**
+ * The port's code for a server's answer, **by Wow's error code first**: the
+ * code says what the server decided, where one HTTP status carries several
+ * decisions (a `400` is a stale version on no server, but a bad title and a
+ * missing application alike). Only an answer without a code the store knows
+ * — a gateway's own page, a proxy, a code a later server adds — falls back to
+ * the status, and no answer at all (a network failure, a timeout, an abort)
+ * is `UNAVAILABLE`: the outcome is unknown, and a retry under the same
+ * `requestId` is what the port expects.
+ */
+export declare function portCodeOf(errorCode: string | undefined, status: number | undefined): ViewStoreErrorCode;
+/** What a failed request threw, read as a {@link Failure}. */
+export declare function failureOf(error: unknown): Promise<Failure>;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { WowViewStore, type WowViewStoreOptions } from './wowViewStore.js';
+export { SHARED_OWNER_ID, SYSTEM_OWNER_ID, SYSTEM_TENANT_ID } from './paths.js';
+export { WowViewStoreErrorCodes } from './errors.js';

package/dist/index.es.js

@@ -0,0 +1,604 @@
+import { ResultExtractors as e } from "@ahoo-wang/fetcher";
+import { CommandHeaders as t, CommandStage as n, ErrorCodes as r, asc as i, filter as a, listQuery as o, singleQuery as s, toWowError as c } from "@ahoo-wang/wow-client";
+import { ViewStoreError as l, isSystemInstanceId as u, isViewStoreError as d } from "@ahoo-wang/wow-view-engine";
+//#region \0rolldown/runtime.js
+var f = Object.freeze({
+	VIEW_INVALID: "ViewInvalid",
+	VIEW_APP_REQUIRED: "ViewAppRequired",
+	SYSTEM_VIEW_READ_ONLY: "SystemViewReadOnly",
+	VIEW_SCOPE_REQUIRED: "ViewScopeRequired",
+	VIEW_EVENT_STREAM_CLOSED: "ViewEventStreamClosed"
+}), p = "referenced-by-shared-dashboard", m = {
+	[r.COMMAND_EXPECT_VERSION_CONFLICT]: "CONFLICT",
+	[r.EVENT_VERSION_CONFLICT]: "CONFLICT",
+	[r.SOURCING_VERSION_CONFLICT]: "CONFLICT",
+	[r.NOT_FOUND]: "NOT_FOUND",
+	[r.ILLEGAL_ACCESS_DELETED_AGGREGATE]: "NOT_FOUND",
+	[r.ILLEGAL_ACCESS_OWNER_AGGREGATE]: "FORBIDDEN",
+	[r.ILLEGAL_ACCESS_SPACE_AGGREGATE]: "FORBIDDEN",
+	[r.ILLEGAL_ACCESS_QUERY_SCOPE]: "FORBIDDEN",
+	[f.SYSTEM_VIEW_READ_ONLY]: "FORBIDDEN",
+	[f.VIEW_EVENT_STREAM_CLOSED]: "FORBIDDEN",
+	[f.VIEW_INVALID]: "INVALID",
+	[f.VIEW_APP_REQUIRED]: "INVALID",
+	[f.VIEW_SCOPE_REQUIRED]: "INVALID",
+	[r.BAD_REQUEST]: "INVALID",
+	[r.ILLEGAL_ARGUMENT]: "INVALID",
+	[r.ILLEGAL_STATE]: "UNAVAILABLE",
+	[r.COMMAND_VALIDATION]: "INVALID",
+	[r.DUPLICATE_AGGREGATE_ID]: "INVALID",
+	[r.QUERY_SCHEMA_VALIDATION]: "INVALID",
+	[r.REQUEST_TIMEOUT]: "UNAVAILABLE",
+	[r.TOO_MANY_REQUESTS]: "UNAVAILABLE",
+	[r.INTERNAL_SERVER_ERROR]: "UNAVAILABLE",
+	[r.QUERY_SCHEMA_UNAVAILABLE]: "UNAVAILABLE",
+	[r.QUERY_SCHEMA_CONFLICT]: "UNAVAILABLE"
+}, Failure = class {
+	constructor(e, t, n) {
+		this.cause = e, this.wow = t, this.status = n;
+	}
+	get errorCode() {
+		return this.wow?.errorCode;
+	}
+	get bindingErrors() {
+		return this.wow?.bindingErrors ?? [];
+	}
+	get unfilled() {
+		if (!(this.wow || this.status !== void 0)) for (let e = this.cause, t = 0; e && t < 4; t++) {
+			let t = e.message, n = typeof t == "string" ? h.exec(t) : null;
+			if (n) return n[1];
+			e = e.cause;
+		}
+	}
+	get code() {
+		return this.unfilled === void 0 ? portCodeOf(this.errorCode, this.status) : "INVALID";
+	}
+	get reached() {
+		return this.wow !== void 0 || this.status !== void 0;
+	}
+	get message() {
+		if (this.wow) return this.wow.message;
+		let e = this.unfilled;
+		return e === void 0 ? this.status === void 0 ? `The view store could not be reached: ${reasonOf(this.cause)}` : `The view store answered HTTP ${this.status}` : `The fetcher's interceptors did not fill the path variable {${e}}`;
+	}
+	toStoreError() {
+		return new l(this.code, this.message, this.held());
+	}
+	held() {
+		let e = this.errorCode;
+		return {
+			cause: this.cause,
+			...e === void 0 ? {} : { detail: { code: e } },
+			...this.code === "UNAVAILABLE" && this.reached ? { reachable: !0 } : {}
+		};
+	}
+}, h = /^Missing required path parameter: (\S+)/;
+function isDuplicateRequest(e) {
+	return e.errorCode === r.DUPLICATE_REQUEST_ID;
+}
+function portCodeOf(e, t) {
+	let n = e === void 0 ? void 0 : m[e];
+	if (n) return n;
+	switch (t) {
+		case 400:
+		case 422: return "INVALID";
+		case 401:
+		case 403: return "FORBIDDEN";
+		case 404:
+		case 410: return "NOT_FOUND";
+		case 409:
+		case 412: return "CONFLICT";
+		default: return "UNAVAILABLE";
+	}
+}
+async function failureOf(e) {
+	let t = await c(e);
+	return new Failure(e, t, t?.status ?? statusOf(e));
+}
+function statusOf(e) {
+	if (typeof e == "object" && e) return e.exchange?.response?.status;
+}
+function reasonOf(e) {
+	if (typeof e == "object" && e) {
+		let { name: t, message: n } = e;
+		if (typeof n == "string") return typeof t == "string" ? `${t}: ${n}` : n;
+	}
+	return String(e);
+}
+//#endregion
+//#region src/paths.ts
+var g = "(shared)", _ = "(system)", v = "(platform)", y = "/view-store/tenant/{tenantId}/owner/{ownerId}", b = {
+	views: `${y}/view`,
+	view: `${y}/view/{id}`,
+	save: `${y}/view/{id}/save`,
+	rename: `${y}/view/{id}/rename`,
+	share: `${y}/view/{id}/share`,
+	claim: `${y}/view/{id}/claim`,
+	single: `${y}/view/snapshot/single`,
+	list: `${y}/view/snapshot/list`,
+	replay: `${y}/view/requests/{requestId}`,
+	systemViews: `${y}/system-views`,
+	systemView: `${y}/system-views/{id}`,
+	preferences: `${y}/definitions/{definitionId}/preferences`
+};
+function pathAt(e, t = {}) {
+	switch (e) {
+		case "shared": return {
+			...t,
+			ownerId: g
+		};
+		case "system": return {
+			...t,
+			tenantId: v,
+			ownerId: _
+		};
+		default: return { ...t };
+	}
+}
+//#endregion
+//#region src/wire.ts
+function isStored(e) {
+	return e.source === "stored" && typeof e.version == "number";
+}
+var x = [
+	"aggregateId",
+	"version",
+	"state.definitionId",
+	"state.title",
+	"state.audience",
+	"state.config.kind"
+];
+function revisionOf(e) {
+	return String(e);
+}
+function toInstance(e) {
+	let { aggregateId: t, version: n, state: r } = e;
+	return {
+		id: t,
+		definitionId: r.definitionId,
+		title: r.title,
+		scope: r.audience,
+		revision: revisionOf(n),
+		config: r.config
+	};
+}
+function toSummary(e) {
+	let { aggregateId: t, version: n, state: r } = e;
+	return {
+		id: t,
+		definitionId: r.definitionId,
+		title: r.title,
+		scope: r.audience,
+		kind: r.config.kind,
+		revision: revisionOf(n)
+	};
+}
+function systemInstance(e) {
+	return {
+		id: e.id,
+		definitionId: e.definitionId,
+		title: e.title,
+		scope: "system",
+		revision: e.revision,
+		config: e.config,
+		...isStored(e) ? { stored: !0 } : {}
+	};
+}
+function systemSummary(e) {
+	return {
+		id: e.id,
+		definitionId: e.definitionId,
+		title: e.title,
+		scope: "system",
+		kind: e.kind,
+		revision: e.revision,
+		...isStored(e) ? { stored: !0 } : {}
+	};
+}
+function toPreferences(e) {
+	return preferencesAt({
+		order: e.order ?? [],
+		defaultInstanceId: e.defaultInstanceId ?? null,
+		autoRun: e.autoRun ?? void 0,
+		lastTabs: e.lastTabs ?? void 0
+	}, e.version);
+}
+function preferencesInput(e) {
+	let { order: t, defaultInstanceId: n, autoRun: r, lastTabs: i } = e;
+	return {
+		order: [...t],
+		defaultInstanceId: n ?? null,
+		...r === void 0 ? {} : { autoRun: r },
+		...i === void 0 ? {} : { lastTabs: { ...i } }
+	};
+}
+function preferencesAt(e, t) {
+	return {
+		...preferencesInput(e),
+		revision: revisionOf(t)
+	};
+}
+function samePreferences(e, t) {
+	return canonical(e) === canonical(t);
+}
+function canonical(e) {
+	let { order: t, defaultInstanceId: n, autoRun: r, lastTabs: i } = preferencesInput(e), a = i && Object.entries(i).sort(([e], [t]) => e < t ? -1 : +(e > t));
+	return JSON.stringify([
+		t,
+		n,
+		r ?? null,
+		a ?? null
+	]);
+}
+//#endregion
+//#region src/wowViewStore.ts
+var S = 1e3, C = 256, w = Symbol("not replayed"), WowViewStore = class {
+	constructor(e) {
+		this.places = /* @__PURE__ */ new Map(), this.preferenceOutcomes = new Remembered(), this.preferenceAttempts = new Remembered(), this.createAttempts = new Remembered(), this.storedVersions = new Remembered(O), this.fetcher = e.fetcher, e.permissions && (this.permissions = e.permissions);
+	}
+	list(e, t) {
+		return guard(async () => {
+			let n = o({
+				filter: a.eq("state.definitionId", e),
+				projection: { include: x },
+				sort: E,
+				limit: S
+			}), [r, i, s] = await Promise.all([
+				this.json("POST", b.list, "personal", {
+					body: n,
+					signal: t
+				}),
+				this.json("POST", b.list, "shared", {
+					body: n,
+					signal: t
+				}),
+				this.json("GET", b.systemViews, "shared", {
+					query: { definitionId: e },
+					signal: t
+				})
+			]).catch((e) => {
+				throw e instanceof Failure && e.code === "NOT_FOUND" ? unsupported(e) : e;
+			});
+			for (let e of s) this.rememberSystem(e);
+			let c = /* @__PURE__ */ new Map();
+			for (let e of [
+				...r.map(toSummary),
+				...i.map(toSummary),
+				...s.map(systemSummary)
+			]) c.has(e.id) || (c.set(e.id, e), this.places.set(e.id, e.scope));
+			return [...c.values()].sort((e, t) => D[e.scope] - D[t.scope]);
+		});
+	}
+	get(e, t) {
+		return guard(async () => (await this.find(e, t)).instance);
+	}
+	create(e, t) {
+		return guard(async () => {
+			let n = e.scope, { requestId: r } = t;
+			if (this.createAttempts.has(r)) {
+				let e = await this.probe(n, t, !0), r = e?.status === 200 ? await e.json() : null;
+				if (r?.aggregateId) return this.places.set(r.aggregateId, n), n === "system" ? this.readAt("system", r.aggregateId, t.signal) : toInstance(r);
+			}
+			this.createAttempts.set(r, !0);
+			let { definitionId: i, title: a, config: o } = e, s = {
+				method: "POST",
+				url: b.views,
+				sentTo: n,
+				body: {
+					definitionId: i,
+					title: a,
+					config: o
+				},
+				landsAt: n
+			}, c = await this.json(s.method, s.url, n, {
+				body: s.body,
+				headers: writeHeaders(t),
+				signal: t.signal
+			}).catch(async (e) => {
+				throw await this.unsupportedOr(e, t.signal);
+			});
+			return await this.landed(c.aggregateId, s, c, t);
+		});
+	}
+	save(e, t, n, r) {
+		return this.write(e, n, r, (e) => ({
+			method: "PUT",
+			url: b.save,
+			sentTo: e,
+			body: { config: t },
+			landsAt: e
+		}));
+	}
+	rename(e, t, n, r) {
+		return this.write(e, n, r, (e) => ({
+			method: "PUT",
+			url: b.rename,
+			sentTo: e,
+			body: { title: t },
+			landsAt: e
+		}));
+	}
+	changeAudience(e, t, n, r) {
+		return this.write(e, n, r, (e) => e === "system" ? readOnly("A system view never moves audience") : t === "shared" ? {
+			method: "PUT",
+			url: b.share,
+			sentTo: e,
+			body: {},
+			landsAt: "shared"
+		} : {
+			method: "PUT",
+			url: b.claim,
+			sentTo: "personal",
+			landsAt: "personal"
+		});
+	}
+	async delete(e, t, n) {
+		await this.write(e, t, n, (e) => ({
+			method: "DELETE",
+			url: b.view,
+			sentTo: e,
+			body: {},
+			landsAt: null
+		}));
+	}
+	getPreferences(e, t) {
+		return guard(async () => toPreferences(await this.json("GET", b.preferences, "personal", {
+			path: { definitionId: e },
+			signal: t
+		}).catch(async (e) => {
+			throw await this.unsupportedOr(e, t);
+		})));
+	}
+	setPreferences(e, t, n) {
+		return guard(async () => {
+			let { requestId: r, signal: i } = n, a = this.preferenceOutcomes.get(r);
+			if (a) return structuredClone(a);
+			let o = this.preferenceAttempts.has(r);
+			this.preferenceAttempts.set(r, !0);
+			let s;
+			try {
+				let r = await this.json("PUT", b.preferences, "personal", {
+					path: { definitionId: e },
+					body: preferencesInput(t),
+					headers: writeHeaders(n, t.revision),
+					signal: i
+				});
+				s = typeof r.aggregateVersion == "number" ? preferencesAt(t, r.aggregateVersion) : await this.getPreferences(e, i);
+			} catch (n) {
+				if (!(n instanceof Failure) || n.code !== "CONFLICT" && !isDuplicateRequest(n)) throw await this.unsupportedOr(n, i);
+				let r = await this.getPreferences(e, i);
+				if ((o || isDuplicateRequest(n)) && samePreferences(r, t)) s = r;
+				else throw new l("CONFLICT", n.message, {
+					...n.held(),
+					preferences: r
+				});
+			}
+			return this.preferenceOutcomes.set(r, s), structuredClone(s);
+		});
+	}
+	write(e, t, n, r) {
+		return guard(async () => {
+			let { signal: i } = n, a = this.places.get(e), o = a ?? (await this.find(e, i)).place, s = a === void 0;
+			for (;;) {
+				let a = r(o), c = t;
+				if (o === "system") {
+					let r = await this.storedVersion(e, t, a, n);
+					if ("answer" in r) return r.answer;
+					c = r.version;
+				}
+				let l;
+				try {
+					l = await this.json(a.method, a.url, a.sentTo, {
+						path: { id: e },
+						body: a.body,
+						headers: writeHeaders(n, c),
+						signal: i
+					});
+				} catch (t) {
+					if (!(t instanceof Failure)) throw t;
+					let c = await this.replayed(e, a, n, t);
+					if (c !== w) return c;
+					if (!s && (t.code === "NOT_FOUND" || t.code === "FORBIDDEN")) {
+						s = !0;
+						let t = (await this.find(e, i, null)).place;
+						if (t !== o && r(t).sentTo !== a.sentTo) {
+							o = t;
+							continue;
+						}
+					}
+					throw t.code === "CONFLICT" || isDuplicateRequest(t) ? await this.conflict(e, t, i) : await this.refusal(t, i);
+				}
+				return this.landed(e, a, l, n);
+			}
+		});
+	}
+	async landed(e, t, n, r) {
+		if (t.landsAt === null) return;
+		this.places.set(e, t.landsAt);
+		let i = n.aggregateVersion, a, o;
+		try {
+			if (a = await this.readAt(t.landsAt, e, r.signal), typeof i != "number" || a.revision === revisionOf(i) || t.landsAt === "system" && this.storedVersions.get(e)?.version === i) return a;
+		} catch (e) {
+			o = e;
+		}
+		let s = await this.replay(e, t, r, !1);
+		if (s !== w && s !== void 0) return s;
+		if (a) return a;
+		throw o;
+	}
+	async replayed(e, t, n, r) {
+		return r.code === "CONFLICT" || r.code === "NOT_FOUND" || isDuplicateRequest(r) ? this.replay(e, t, n, !0) : w;
+	}
+	async replay(e, t, n, r) {
+		let i = t.sentTo === "system" ? ["system"] : t.sentTo === "personal" ? ["personal", "shared"] : ["shared", "personal"];
+		for (let [a, o] of i.entries()) {
+			let i = await this.probe(o, n, r && a === 0);
+			if (!i) continue;
+			if (i.status === 204) return t.landsAt === null ? void 0 : w;
+			let s = await i.json();
+			return t.landsAt === null || s?.aggregateId !== e ? w : t.landsAt === "system" ? this.readAt("system", e, n.signal) : toInstance(s);
+		}
+		return w;
+	}
+	async probe(e, t, n) {
+		try {
+			return await this.send("GET", b.replay, e, {
+				path: { requestId: t.requestId },
+				signal: t.signal
+			});
+		} catch (e) {
+			if (e instanceof Failure && (e.code === "NOT_FOUND" || !n)) return;
+			throw e;
+		}
+	}
+	async conflict(e, t, n) {
+		let { instance: r } = await this.find(e, n, null);
+		return new l("CONFLICT", t.message, {
+			...t.held(),
+			instance: r
+		});
+	}
+	async refusal(e, t) {
+		let n = e.bindingErrors.filter((e) => e.code === p);
+		if (e.code !== "INVALID" || n.length === 0) return e.toStoreError();
+		let r = await Promise.all(n.map((e) => this.boardTitle(e, t)));
+		return new l("INVALID", e.message, {
+			...e.held(),
+			boards: r
+		});
+	}
+	async boardTitle(e, t) {
+		if (typeof e.msg == "string" && e.msg.trim() !== "") return e.msg;
+		try {
+			return (await this.readAt("shared", e.name, t)).title;
+		} catch {
+			return e.name;
+		}
+	}
+	async find(e, t, n = this.places.get(e)) {
+		if (!u(e)) {
+			let r = [
+				"personal",
+				"shared",
+				"system"
+			];
+			n && r.sort((e, t) => Number(t === n) - Number(e === n));
+			for (let n of r) try {
+				let r = await this.readAt(n, e, t);
+				return this.places.set(e, n), {
+					place: n,
+					instance: r
+				};
+			} catch (e) {
+				if (e instanceof Failure && e.code === "NOT_FOUND") continue;
+				throw e;
+			}
+			if (!await this.served(t)) throw new l("UNSUPPORTED", T);
+		}
+		throw new l("NOT_FOUND", `No such view: ${e}`);
+	}
+	async served(e) {
+		try {
+			return await this.send("GET", b.systemViews, "shared", { signal: e }), !0;
+		} catch (e) {
+			return !(e instanceof Failure && e.code === "NOT_FOUND");
+		}
+	}
+	async unsupportedOr(e, t) {
+		return e instanceof Failure && e.code === "NOT_FOUND" && !await this.served(t) ? unsupported(e) : e;
+	}
+	rememberSystem(e) {
+		return this.storedVersions.set(e.id, isStored(e) ? {
+			revision: e.revision,
+			version: e.version
+		} : null), e;
+	}
+	async storedVersion(e, t, n, r) {
+		let i = this.storedVersions.get(e);
+		if (i === null && readOnly("Configured system views are read-only"), i?.revision !== t) {
+			let a = await this.readAt("system", e, r.signal);
+			if (i = this.storedVersions.get(e), i && i.revision !== t) {
+				let i = await this.replay(e, n, r, !1);
+				if (i !== w) return { answer: i };
+				throw new l("CONFLICT", `System view ${e} has moved on from revision ${t}`, { instance: a });
+			}
+		}
+		return i || readOnly("Configured system views are read-only"), { version: String(i.version) };
+	}
+	async readAt(e, t, n) {
+		return e === "system" ? systemInstance(this.rememberSystem(await this.json("GET", b.systemView, "shared", {
+			path: { id: t },
+			signal: n
+		}))) : toInstance(await this.json("POST", b.single, e, {
+			body: s({ filter: a.id(t) }),
+			signal: n
+		}));
+	}
+	async json(e, t, n, r) {
+		return await (await this.send(e, t, n, r)).json();
+	}
+	async send(t, n, r, { path: i, query: a, body: o, headers: s, signal: c }) {
+		try {
+			return await this.fetcher.request({
+				url: n,
+				method: t,
+				urlParams: {
+					path: pathAt(r, i),
+					query: a
+				},
+				body: o,
+				headers: s,
+				signal: c
+			}, { resultExtractor: e.Response });
+		} catch (e) {
+			throw await failureOf(e);
+		}
+	}
+};
+function writeHeaders(e, r) {
+	return {
+		[t.REQUEST_ID]: e.requestId,
+		[t.WAIT_STAGE]: n.SNAPSHOT,
+		...r === void 0 ? {} : { [t.AGGREGATE_VERSION]: r }
+	};
+}
+var T = "This server has no view store";
+function unsupported(e) {
+	return new l("UNSUPPORTED", T, e.held());
+}
+var E = [i("firstEventTime"), i("aggregateId")], D = {
+	system: 0,
+	shared: 1,
+	personal: 2
+};
+function readOnly(e) {
+	throw new l("FORBIDDEN", e);
+}
+async function guard(e) {
+	try {
+		return await e();
+	} catch (e) {
+		throw e instanceof Failure ? e.toStoreError() : d(e) ? e : new l("UNAVAILABLE", e instanceof Error ? e.message : String(e), {
+			cause: e,
+			...e instanceof SyntaxError ? { reachable: !0 } : {}
+		});
+	}
+}
+var O = 1024, Remembered = class {
+	constructor(e = C) {
+		this.limit = e, this.entries = /* @__PURE__ */ new Map();
+	}
+	get(e) {
+		return this.entries.get(e);
+	}
+	has(e) {
+		return this.entries.has(e);
+	}
+	set(e, t) {
+		this.entries.delete(e), this.entries.set(e, t), this.entries.size > this.limit && this.entries.delete(this.entries.keys().next().value);
+	}
+};
+//#endregion
+export { g as SHARED_OWNER_ID, _ as SYSTEM_OWNER_ID, v as SYSTEM_TENANT_ID, WowViewStore, f as WowViewStoreErrorCodes };
+
+//# sourceMappingURL=index.es.js.map