@aiao/rxdb-adapter-http 0.0.26

package/dist/index.js

@@ -0,0 +1,864 @@
+import { NetworkOfflineError as e, PropertyType as t, RxDBAdapterRemoteBase as n, getEntityMetadata as r, getSyncConfig as i, getSyncType as a, isSystemEntity as o } from "@aiao/rxdb";
+import { defer as s, from as c, map as l, of as u } from "rxjs";
+//#region src/errors.ts
+var d = class e extends Error {
+	code;
+	constructor(t, n) {
+		super(t), this.code = n, this.name = "HttpAdapterError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, f = class e extends d {
+	field;
+	value;
+	constructor(t, n, r) {
+		super(t, "CONFIG_ERROR"), this.field = n, this.value = r, this.name = "HttpConfigError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, p = class e extends d {
+	operation;
+	constructor(t) {
+		super(`HTTP adapter does not support changelog operation "${t}" (v1 has no Full-sync)`, "CHANGELOG_UNSUPPORTED"), this.operation = t, this.name = "HttpChangelogUnsupportedError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, m = class e extends d {
+	entity;
+	property;
+	propertyType;
+	constructor(t, n, r) {
+		super(`HTTP adapter has no wire codec for property type "${r}" at "${t}.${n}"`, "UNSUPPORTED_WIRE_TYPE"), this.entity = t, this.property = n, this.propertyType = r, this.name = "HttpUnsupportedWireTypeError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, h = class e extends d {
+	operation;
+	reason;
+	constructor(t, n = "v1 supports SyncType.QueryCache only") {
+		super(`HTTP adapter does not support "${t}": ${n}`, "UNSUPPORTED_OPERATION"), this.operation = t, this.reason = n, this.name = "HttpUnsupportedOperationError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, g = class e extends d {
+	handler;
+	entityName;
+	constructor(t, n, r) {
+		super(`${t} handler for "${n}" returned an unexpected shape: ${r}`, "HANDLER_CONTRACT"), this.handler = t, this.entityName = n, this.name = "HttpHandlerContractError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, _ = class e extends d {
+	reason;
+	constructor(t, n) {
+		super(n, "PAGINATION_ERROR"), this.reason = t, this.name = "HttpPaginationError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, v = class e extends d {
+	entityName;
+	detail;
+	constructor(t, n) {
+		super(`HTTP adapter received invalid metadata for "${t}": ${n}`, "INVALID_METADATA"), this.entityName = t, this.detail = n, this.name = "HttpInvalidMetadataError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, y = class e extends d {
+	operation;
+	constructor(t) {
+		super(`HTTP adapter is disconnected; "${t}" was cancelled or rejected`, "DISCONNECTED"), this.operation = t, this.name = "HttpDisconnectedError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, b = class e extends d {
+	status;
+	url;
+	detail;
+	constructor(t, n, r) {
+		super(`HTTP ${t} from ${n} returned a non-JSON body: ${r}`, "INVALID_RESPONSE"), this.status = t, this.url = n, this.detail = r, this.name = "HttpInvalidResponseError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, x = class e extends d {
+	reason;
+	operation;
+	constructor(t, n, r) {
+		super(`HTTP request for "${n}" could not be built (${t}): ${r}`, "REQUEST_BUILD_ERROR"), this.reason = t, this.operation = n, this.name = "HttpRequestBuildError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, S = class e extends d {
+	status;
+	url;
+	body;
+	constructor(t, n, r) {
+		super(`HTTP ${t} from ${n}`, "HTTP_RESPONSE_ERROR"), this.status = t, this.url = n, this.body = r, this.name = "HttpResponseError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, C = {
+	pageSize: 1e3,
+	idChunkSize: 100,
+	maxEmptyPages: 3,
+	maxPages: 1e3,
+	requestTimeoutMs: 3e4,
+	conditionalCacheSize: 256
+}, w = /* @__PURE__ */ new Set(["maxEmptyPages"]), ee = (e, t) => {
+	let n = +!w.has(e);
+	if (!Number.isInteger(t) || t < n) throw new f(`HTTP adapter config "${e}" must be a finite integer >= ${n}, received ${String(t)}`, e, t);
+}, te = (e) => {
+	let t = {};
+	for (let n of Object.keys(C)) {
+		let r = e[n] ?? C[n];
+		ee(n, r), t[n] = r;
+	}
+	return t;
+}, T = ["entity"], E = {
+	fetchMetadata: {
+		method: "POST",
+		path: ":entity/metadata",
+		placeholders: T,
+		closable: !1,
+		carriesBody: !0
+	},
+	findByIds: {
+		method: "POST",
+		path: ":entity/by-ids",
+		placeholders: T,
+		closable: !1,
+		carriesBody: !0
+	},
+	create: {
+		method: "POST",
+		path: ":entity",
+		placeholders: T,
+		closable: !0,
+		carriesBody: !0
+	},
+	update: {
+		method: "PATCH",
+		path: ":entity/:id",
+		placeholders: ["entity", "id"],
+		closable: !0,
+		carriesBody: !0
+	},
+	delete: {
+		method: "POST",
+		path: ":entity/delete",
+		placeholders: T,
+		closable: !0,
+		carriesBody: !0
+	},
+	version: {
+		method: "GET",
+		placeholders: [],
+		closable: !0,
+		carriesBody: !1
+	},
+	isTableExisted: {
+		method: "HEAD",
+		placeholders: T,
+		closable: !0,
+		carriesBody: !1
+	}
+}, D = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+]), ne = /* @__PURE__ */ new Set(["GET", "HEAD"]), O = /:([a-zA-Z][a-zA-Z0-9_]*)/g, k = /[\s?#]/, re = "(server version)", ie = (e) => typeof e == "object" && !!e && !Array.isArray(e), ae = (e) => [...e.matchAll(O)].map((e) => e[1]), oe = (e, t, n) => {
+	let r = `templates.${e}`;
+	if (typeof t.path != "string" || t.path.trim().length === 0) throw new f(`REST template "${r}.path" must be a non-empty string, received ${JSON.stringify(t.path)}`, `${r}.path`, t.path);
+	if (k.test(t.path)) throw new f(`REST template "${r}.path" must not contain whitespace, "?" or "#", received "${t.path}"`, `${r}.path`, t.path);
+	if (t.method !== void 0 && !D.has(t.method)) throw new f(`REST template "${r}.method" must be one of ${[...D].join(" / ")}, received ${JSON.stringify(t.method)}`, `${r}.method`, t.method);
+	if (n.carriesBody && t.method !== void 0 && ne.has(t.method)) throw new f(`REST template "${r}.method" cannot be "${t.method}": the "${e}" handler always sends a request body, and ${t.method} requests cannot carry a body`, `${r}.method`, t.method);
+	let i = new Set(ae(t.path)), a = new Set(n.placeholders), o = [...a].filter((e) => !i.has(e)), s = [...i].filter((e) => !a.has(e));
+	if (o.length === 0 && s.length === 0) return;
+	let c = [o.length > 0 ? `missing ${o.map((e) => `":${e}"`).join(", ")}` : void 0, s.length > 0 ? `unexpected ${s.map((e) => `":${e}"`).join(", ")}` : void 0].filter(Boolean).join("; ");
+	throw new f(`REST template "${r}.path" must use exactly ${a.size === 0 ? "no placeholder" : [...a].map((e) => `":${e}"`).join(" and ")} — ${c} in "${t.path}"`, `${r}.path`, t.path);
+}, se = (e) => {
+	let t = {};
+	for (let n of Object.keys(E)) {
+		let r = E[n], i = e?.[n];
+		if (i === null) {
+			if (!r.closable) throw new f(`REST template "templates.${n}" cannot be disabled: it backs a required RxDBAdapterRemoteBase member`, `templates.${n}`, i);
+			continue;
+		}
+		let a = i?.path ?? r.path;
+		if (a === void 0) continue;
+		let o = {
+			path: a,
+			method: i?.method ?? r.method
+		};
+		oe(n, o, r), t[n] = o;
+	}
+	return t;
+}, ce = (e) => {
+	for (let [t, n] of Object.entries(e ?? {})) if (typeof n != "string" || n.trim().length === 0 || k.test(n)) throw new f(`REST resource mapping "resources.${t}" must be a non-empty path fragment without whitespace, "?" or "#", received ${JSON.stringify(n)}`, `resources.${t}`, n);
+	return e;
+}, A = (e, t) => {
+	let n = e?.[t];
+	if (n !== void 0) return n;
+	if (k.test(t) || t.includes("/")) throw new f(`REST templates cannot use entity name "${t}" as a path fragment; add an explicit "resources.${t}" mapping`, `resources.${t}`, void 0);
+	return t;
+}, le = (e, t, n) => {
+	if (typeof n != "string" || n.length === 0) throw new x("id", e, `REST templates require a non-empty string id for "${t}", received ${JSON.stringify(n) ?? typeof n}`);
+	return encodeURIComponent(n);
+}, j = (e, t, n) => ({
+	url: t.path.replace(O, (r, i) => {
+		let a = n[i];
+		if (a === void 0) throw new f(`REST template "templates.${e}.path" has no value for placeholder ":${i}"`, `templates.${e}.path`, t.path);
+		return a;
+	}),
+	method: t.method
+}), ue = (e = {}) => {
+	let t = ce(e.resources), n = se(e.templates), r = (e, n, r) => j(e, n, { entity: A(t, r) }), i = n.fetchMetadata, a = n.findByIds, o = {
+		onFetchMetadata: {
+			request: (e) => ({
+				...r("fetchMetadata", i, e.entityName),
+				body: {
+					where: e.where,
+					offset: e.offset,
+					limit: e.limit,
+					pageToken: e.pageToken
+				}
+			}),
+			parse: (e) => e
+		},
+		onFindByIds: {
+			request: (e) => ({
+				...r("findByIds", a, e.entityName),
+				body: { ids: e.ids }
+			}),
+			parse: (e) => e
+		}
+	}, { create: s, update: c, delete: l, version: u, isTableExisted: d } = n;
+	return s && (o.onCreate = {
+		request: (e) => ({
+			...r("create", s, e.entityName),
+			body: e.data
+		}),
+		parse: (e) => e
+	}), c && (o.onUpdate = {
+		request: (e) => ({
+			...j("update", c, {
+				entity: A(t, e.entityName),
+				id: le("update", e.entityName, e.id)
+			}),
+			body: e.data
+		}),
+		parse: (e) => e
+	}), l && (o.onDelete = { request: (e) => ({
+		...r("delete", l, e.entityName),
+		body: { ids: e.ids }
+	}) }), u && (o.onVersion = {
+		request: () => j("version", u, {}),
+		parse: (e) => {
+			if (typeof e == "string") return e;
+			if (ie(e) && typeof e.version == "string") return e.version;
+			throw new g("version", re, `expected a version string or { version: string }, received ${JSON.stringify(e)}`);
+		}
+	}), d && (o.onIsTableExisted = { request: (e) => r("isTableExisted", d, e.entityName) }), o;
+}, de = 0, fe = "public", pe = 1e3, M = 3e4, N = 3, P = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a = 0;
+	#o = !0;
+	#s;
+	constructor(e) {
+		if (this.#e = e, z(e.url), this.#t = L(e.options.reconnectBaseDelayMs, "reconnectBaseDelayMs"), this.#n = L(e.options.reconnectMaxDelayMs, "reconnectMaxDelayMs", M), this.#n < this.#t) throw new f(`HTTP adapter config "changeFeed.reconnectMaxDelayMs" must be >= "changeFeed.reconnectBaseDelayMs" (${this.#t}), received ${this.#n}`, "changeFeed.reconnectMaxDelayMs", this.#n);
+	}
+	start() {
+		this.#o = !1, this.#a = 0, this.#m(), this.#c();
+	}
+	stop() {
+		this.#o = !0, this.#m(), this.#h();
+	}
+	#c() {
+		this.#h();
+		let e = globalThis.EventSource;
+		if (typeof e != "function") {
+			this.#g({
+				reason: "unsupported-runtime",
+				attempt: 0,
+				message: `change feed is enabled but this runtime has no global "EventSource"; no connection will be attempted for ${this.#e.url}`
+			});
+			return;
+		}
+		try {
+			let t = new e(this.#e.url, { withCredentials: this.#e.options.withCredentials === !0 });
+			t.onopen = this.#v, t.onmessage = this.#y, t.onerror = this.#b, this.#r = t;
+		} catch (e) {
+			this.#u(void 0, e instanceof Error ? e.message : String(e));
+		}
+	}
+	#l() {
+		for (let e of this.#e.entities()) this.#e.invalidate(e.name, e.namespace);
+	}
+	#u(e, t) {
+		this.#d() && (this.#a = 0), this.#s = void 0, this.#a++;
+		let n = e === de && this.#a <= N ? void 0 : this.#f();
+		this.#g({
+			reason: "connection-error",
+			attempt: this.#a,
+			readyState: e,
+			retryInMs: n,
+			message: `change feed connection to ${this.#e.url} failed (${t}); EventSource does not expose the status code, so the cause may be an unimplemented endpoint, an authentication failure, or a network error`
+		}), n !== void 0 && (this.#h(), this.#p(n));
+	}
+	#d() {
+		return this.#s !== void 0 && Date.now() - this.#s >= this.#t;
+	}
+	#f() {
+		return Math.min(this.#t * 2 ** (this.#a - 1), this.#n);
+	}
+	#p(e) {
+		this.#m(), this.#i = setTimeout(() => {
+			this.#i = void 0, this.#c();
+		}, e);
+	}
+	#m() {
+		this.#i !== void 0 && (clearTimeout(this.#i), this.#i = void 0);
+	}
+	#h() {
+		let e = this.#r;
+		e !== void 0 && (this.#r = void 0, e.onopen = null, e.onmessage = null, e.onerror = null, e.close());
+	}
+	#g(e) {
+		let t = this.#e.options.onUnavailable;
+		if (t) try {
+			t({
+				...e,
+				url: this.#e.url
+			});
+		} catch {}
+	}
+	#_(e, t) {
+		let n = this.#e.options.onNotification;
+		if (n) try {
+			n({
+				url: this.#e.url,
+				entity: e.entity,
+				namespace: e.namespace,
+				clientId: e.clientId,
+				suppressed: t
+			});
+		} catch {}
+	}
+	#v = () => {
+		this.#s = Date.now(), this.#l();
+	};
+	#y = (e) => {
+		if (this.#o) return;
+		let t = F(e.data);
+		if (t === void 0) {
+			this.#g({
+				reason: "malformed-message",
+				attempt: this.#a,
+				data: typeof e.data == "string" ? e.data : void 0,
+				message: `change feed message from ${this.#e.url} carries no usable entity name; expected JSON like {"entity":"Recipe"}`
+			});
+			return;
+		}
+		let n = t.clientId !== void 0 && t.clientId === this.#e.clientId();
+		this.#_(t, n), !n && this.#e.invalidate(t.entity, t.namespace);
+	};
+	#b = () => {
+		if (this.#o) return;
+		let e = this.#r?.readyState;
+		this.#u(e, `readyState=${String(e)}`);
+	};
+}, F = (e) => {
+	if (typeof e != "string") return;
+	let t = I(e);
+	if (typeof t != "object" || !t) return;
+	let n = t, r = n.entity;
+	if (typeof r != "string" || r.length === 0) return;
+	let i = n.namespace, a = n.clientId;
+	return {
+		entity: r,
+		namespace: typeof i == "string" && i.length > 0 ? i : fe,
+		clientId: typeof a == "string" ? a : void 0
+	};
+}, I = (e) => {
+	try {
+		return JSON.parse(e);
+	} catch {
+		return;
+	}
+}, L = (e, t, n = pe) => {
+	let r = e ?? n;
+	if (!Number.isInteger(r) || r < 1) throw new f(`HTTP adapter config "changeFeed.${t}" must be a finite integer >= 1, received ${String(r)}`, `changeFeed.${t}`, r);
+	return r;
+}, R = (e) => {
+	if (typeof e != "string" || e.trim().length === 0) throw new f("HTTP adapter config \"changeFeed.url\" must be a non-empty string", "changeFeed.url", e);
+}, z = (e) => {
+	if (!URL.canParse(e)) throw new f(`HTTP adapter config "changeFeed.url" resolves to "${e}", which is not a parsable URL`, "changeFeed.url", e);
+}, B = (e, t) => {
+	let n = [];
+	for (let r = 0; r < e.length; r += t) n.push(e.slice(r, r + t));
+	return n;
+}, me = async (e, t) => {
+	let { transport: n, handler: r, config: i } = e, a = [];
+	for (let e of B(t.ids, i.idChunkSize)) {
+		let i = {
+			entityName: t.entityName,
+			ids: e
+		}, o = await n.sendJson(r.request(i), "findByIds", t.entityName), s = r.parse(o, i);
+		if (!Array.isArray(s)) throw new g("findByIds", t.entityName, `expected an array of rows, received ${typeof s}`);
+		a.push(...s);
+	}
+	return a;
+}, he = (e) => typeof e == "object" && !!e && !Array.isArray(e), V = (e, t, n) => {
+	if (!he(n)) throw new g(e, t, `expected the persisted row object, received ${JSON.stringify(n) ?? typeof n}`);
+	return n;
+}, ge = "(server version)", _e = (e) => {
+	if (typeof e != "string" || e.trim() === "") throw new g("version", ge, `expected a non-empty version string, received ${JSON.stringify(e) ?? typeof e}`);
+	return e;
+}, ve = /^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}(:\d{2}(\.\d+)?)?([Zz]|[+-]\d{2}:\d{2})$/, ye = (e) => typeof e == "object" && !!e, be = (e, t, n) => {
+	if (typeof n != "string") throw new v(e, `row "${t}" has updatedAt of type ${typeof n}, expected an ISO 8601 string`);
+	if (!ve.test(n)) throw new v(e, `row "${t}" has updatedAt "${n}", expected ISO 8601 with an explicit time zone`);
+	let r = new Date(n);
+	if (Number.isNaN(r.getTime())) throw new v(e, `row "${t}" has updatedAt "${n}", which is not a real instant`);
+	return r.toISOString();
+}, xe = (e, t) => {
+	let { id: n } = t;
+	if (typeof n != "string" || n.length === 0) throw new v(e, `row has id ${JSON.stringify(n)}, expected a non-empty string`);
+	return n;
+}, Se = (e, t) => {
+	if (!Array.isArray(t)) throw new v(e, `expected an array of metadata rows, received ${typeof t}`);
+	return t.map((t) => {
+		if (!ye(t)) throw new v(e, `expected a metadata object, received ${JSON.stringify(t)}`);
+		let n = xe(e, t);
+		return {
+			id: n,
+			updatedAt: be(e, n, t.updatedAt)
+		};
+	});
+}, Ce = (e, t) => {
+	if (Array.isArray(t)) return {
+		shape: "offset",
+		rows: t
+	};
+	let n = t;
+	if (!n || !Array.isArray(n.rows)) throw new g("fetchMetadata", e, `expected an array of rows or { rows, nextPageToken }, received ${JSON.stringify(t)}`);
+	if (n.nextPageToken === void 0 && n.nextCursor !== void 0) throw new g("fetchMetadata", e, "returned the removed key \"nextCursor\"; rename it to \"nextPageToken\" (reading it as undefined would end pagination at the first page)");
+	if (n.nextPageToken !== void 0 && typeof n.nextPageToken != "string") throw new g("fetchMetadata", e, `expected "nextPageToken" to be a string or undefined, received ${JSON.stringify(n.nextPageToken)}`);
+	return {
+		shape: "token",
+		rows: n.rows,
+		nextPageToken: n.nextPageToken
+	};
+}, we = async (e, t) => {
+	let { transport: n, handler: r, config: i } = e, a = [], o, s = 0, c, l = 0;
+	for (let e = 1;; e++) {
+		if (e > i.maxPages) throw new _("max_pages", `fetchMetadata for "${t.entityName}" exceeded maxPages=${i.maxPages}; refusing to return a truncated result`);
+		let u = {
+			...t,
+			offset: s,
+			limit: i.pageSize,
+			pageToken: c
+		}, d = await n.sendJson(r.request(u), "fetchMetadata", t.entityName), f = Ce(t.entityName, r.parse(d, u));
+		if (o && f.shape !== o) throw new _("shape_switch", `fetchMetadata for "${t.entityName}" started in ${o} mode but page ${e} returned ${f.shape} mode`);
+		if (o = f.shape, a.push(...Se(t.entityName, f.rows)), o === "offset") {
+			if (f.rows.length < i.pageSize) return a;
+			s += f.rows.length;
+			continue;
+		}
+		if (f.nextPageToken === void 0) return a;
+		if (f.nextPageToken === c) throw new _("page_token_not_advancing", `fetchMetadata for "${t.entityName}" received the same nextPageToken "${c}" twice; refusing to loop forever`);
+		l = Te(t.entityName, f.rows.length, l, i.maxEmptyPages), c = f.nextPageToken;
+	}
+}, Te = (e, t, n, r) => {
+	if (t > 0) return 0;
+	let i = n + 1;
+	if (i > r) throw new _("empty_page_limit", `fetchMetadata for "${e}" received ${i} consecutive empty pages (maxEmptyPages=${r}); the remote is spinning`);
+	return i;
+}, H = (e) => structuredClone(e), Ee = (e) => {
+	let t = Object.entries(e ?? {});
+	return t.sort(([e], [t]) => e < t ? -1 : 1), t;
+}, De = (e, t, n, r) => JSON.stringify([
+	e,
+	t,
+	n ?? null,
+	Ee(r)
+]), Oe = class {
+	maxEntries;
+	#e = /* @__PURE__ */ new Map();
+	#t = /* @__PURE__ */ new Map();
+	#n = /* @__PURE__ */ new Set();
+	get size() {
+		return this.#e.size;
+	}
+	constructor(e) {
+		this.maxEntries = e;
+	}
+	get(e) {
+		let t = this.#e.get(e);
+		if (t) return this.#e.delete(e), this.#e.set(e, t), {
+			etag: t.etag,
+			takeValue: () => H(t.value)
+		};
+	}
+	set(e, t) {
+		this.#e.delete(e), this.#e.set(e, {
+			etag: t.etag,
+			value: H(t.value)
+		});
+		for (let e of this.#e.keys()) {
+			if (this.#e.size <= this.maxEntries) break;
+			this.#e.delete(e);
+		}
+	}
+	delete(e) {
+		this.#e.delete(e);
+	}
+	markEtagUnreadable(e) {
+		if (this.#n.has(e)) return !1;
+		this.#n.add(e);
+		for (let e of this.#n) {
+			if (this.#n.size <= this.maxEntries) break;
+			this.#n.delete(e);
+		}
+		return !0;
+	}
+	clear() {
+		this.#e.clear(), this.#n.clear();
+	}
+	async singleFlight(e, t) {
+		let n = this.#t.get(e);
+		if (n) return H(await n);
+		let r = t().finally(() => this.#t.delete(e));
+		return this.#t.set(e, r), r;
+	}
+}, ke = /* @__PURE__ */ new Set(["fetchMetadata", "findByIds"]), Ae = (e) => `${e.entityName === void 0 ? e.operation : `${e.entityName} ${e.operation}`}: conditionalRequests is enabled, but no ETag is readable on this 200 response (${e.url}, Response.type=${e.responseType}); neither this request nor later ones with the same fingerprint will send If-None-Match. Two possibilities, indistinguishable from the client: (1) the server did not send an ETag; (2) the server sent one, but a cross-origin response did not list it in Access-Control-Expose-Headers. A cross-origin response reports Response.type 'cors' in the browser, which is a clue; if your server logs show an ETag that is unreadable here, check (2) first.`, U = (e, t) => /^https?:\/\//i.test(t) ? t : `${e.replace(/\/+$/, "")}/${t.replace(/^\/+/, "")}`, W = (e) => e instanceof Error ? e.message : String(e), G = async (e) => {
+	await e.body?.cancel().catch(() => void 0);
+}, K = async (e, t) => {
+	try {
+		return await e.text();
+	} catch (e) {
+		if (t.aborted) throw e;
+		return;
+	}
+}, q = async (e, t, n) => {
+	if (!e.ok) throw new S(e.status, t, await K(e, n));
+}, je = (e, t) => {
+	if (e === void 0) return;
+	let n;
+	try {
+		n = JSON.stringify(e);
+	} catch (e) {
+		throw new x("body", t, W(e));
+	}
+	if (n === void 0) throw new x("body", t, `JSON.stringify() returned undefined for ${typeof e}`);
+	return n;
+}, Me = /* @__PURE__ */ new Set(["GET", "HEAD"]), Ne = (e, t, n) => {
+	if (t !== void 0 && Me.has(e.toUpperCase())) throw new x("method", n, `${e.toUpperCase()} requests cannot carry a body`);
+}, Pe = (e, t) => {
+	if (!(URL.canParse(e) || globalThis.location !== void 0 && URL.canParse(e, globalThis.location.href))) throw new x("url", t, `"${e}" is not a parsable URL`);
+}, J = (e, t) => {
+	for (let [n, r] of Object.entries(t ?? {})) e[n.toLowerCase()] = r;
+	return e;
+}, Y = (e, t) => {
+	try {
+		return Object.fromEntries(new Headers(e));
+	} catch (e) {
+		throw new x("headers", t, W(e));
+	}
+}, X = async (e, t) => {
+	let n = await e.text();
+	try {
+		return JSON.parse(n);
+	} catch (n) {
+		throw new b(e.status, t, W(n));
+	}
+}, Fe = class {
+	options;
+	#e;
+	constructor(e) {
+		this.options = e, this.#e = e.conditional && new Oe(e.conditional.maxEntries);
+	}
+	async sendJson(e, t, n) {
+		let r = await this.#t(e, t), i = this.#e;
+		if (!i || !ke.has(t)) return this.#r(r, t);
+		let a = De(r.method, r.url, r.body, r.variant);
+		return i.singleFlight(a, () => this.#i(i, a, r, {
+			operation: t,
+			entityName: n
+		}));
+	}
+	clearConditionalCache() {
+		this.#e?.clear();
+	}
+	async sendVoid(e, t) {
+		await this.execute(e, t, async (t) => {
+			await q(t, this.resolveUrl(e), this.options.disconnectSignal), await G(t);
+		});
+	}
+	resolveUrl(e) {
+		return U(this.options.baseUrl, e.url);
+	}
+	async execute(e, t, n) {
+		return this.#n(await this.#t(e, t), t, n);
+	}
+	async buildHeaders(e) {
+		let t = J({}, this.options.headers);
+		return e.body !== void 0 && (t["content-type"] = "application/json"), J(t, e.headers), this.options.auth && J(t, await this.options.auth()), t;
+	}
+	classify(t, n) {
+		return t instanceof d ? t : n.timedOut ? new e(/* @__PURE__ */ Error(`HTTP request to ${n.url} exceeded requestTimeoutMs=${this.options.requestTimeoutMs}`)) : this.options.disconnectSignal.aborted ? new y(n.operation) : new e(t instanceof Error ? t : Error(W(t)));
+	}
+	async #t(e, t) {
+		if (this.options.disconnectSignal.aborted) throw new y(t);
+		let n = await this.buildHeaders(e), r = U(this.options.baseUrl, e.url), i = je(e.body, t);
+		return Pe(r, t), Ne(e.method, i, t), {
+			url: r,
+			method: e.method,
+			headers: Y(n, t),
+			variant: J({}, e.headers),
+			body: i
+		};
+	}
+	async #n(e, t, n) {
+		let { disconnectSignal: r, requestTimeoutMs: i, reportResult: a } = this.options, o = new AbortController(), s = !1, c = setTimeout(() => {
+			s = !0, o.abort();
+		}, i), l = AbortSignal.any([r, o.signal]);
+		try {
+			let t = await n(await fetch(e.url, {
+				method: e.method,
+				headers: e.headers,
+				body: e.body,
+				signal: l
+			}));
+			return a?.(null), t;
+		} catch (n) {
+			let r = this.classify(n, {
+				operation: t,
+				url: e.url,
+				timedOut: s
+			});
+			throw a?.(r), r;
+		} finally {
+			clearTimeout(c);
+		}
+	}
+	async #r(e, t) {
+		return this.#n(e, t, async (t) => (await q(t, e.url, this.options.disconnectSignal), X(t, e.url)));
+	}
+	async #i(e, t, n, r) {
+		let i = e.get(t), a = i ? {
+			...n,
+			headers: {
+				...n.headers,
+				"if-none-match": i.etag
+			}
+		} : n;
+		return this.#n(a, r.operation, async (a) => i && a.status === 304 ? (await G(a), i.takeValue()) : (await q(a, n.url, this.options.disconnectSignal), this.#a(e, t, n.url, a, r)));
+	}
+	async #a(e, t, n, r, i) {
+		let a = await X(r, n), o = r.headers.get("etag");
+		return o === null ? (e.delete(t), this.#o(e, t, n, r, i), a) : (e.set(t, {
+			etag: o,
+			value: a
+		}), a);
+	}
+	#o(e, t, n, r, i) {
+		let a = this.options.conditional?.onEtagUnreadable;
+		if (!a || !e.markEtagUnreadable(t)) return;
+		let o = {
+			operation: i.operation,
+			entityName: i.entityName,
+			url: n,
+			responseType: r.type
+		};
+		try {
+			a({
+				...o,
+				message: Ae(o)
+			});
+		} catch {}
+	}
+}, Z = "http", Ie = {
+	combinator: "and",
+	rules: []
+}, Q = /* @__PURE__ */ new Set([t.bigint, t.binary]), Le = class extends n {
+	options;
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a = !1;
+	name = Z;
+	config;
+	get changeFeedEnabled() {
+		return this.#i;
+	}
+	constructor(e, t) {
+		super(e), this.options = t, ze(t.baseUrl), Be(t.handlers), this.config = te(t), this.#e = t.handlers, this.#t = new AbortController(), this.#n = this.#o(), this.#r = this.#s(), this.#i = this.#r !== void 0, this.#f();
+	}
+	async connect() {
+		return this.#p(), this.#t.abort(), this.#t = new AbortController(), this.#n = this.#o(), this.#a = !0, this.#i && this.#r?.start(), this;
+	}
+	async disconnect() {
+		return this.#a = !1, this.#t.abort(), this.#n.clearConditionalCache(), this.#r?.stop(), Promise.resolve();
+	}
+	startChangeFeed() {
+		if (!this.#a) throw new y("startChangeFeed");
+		let e = this.#d("startChangeFeed");
+		this.#i = !0, e.start();
+	}
+	stopChangeFeed() {
+		let e = this.#d("stopChangeFeed");
+		this.#i = !1, e.stop();
+	}
+	async version() {
+		this.#u("version");
+		let e = this.#e.onVersion;
+		if (!e) throw new h("version", "no \"onVersion\" handler is configured; the adapter must not report its own package version as the backend version");
+		let t = await this.#n.sendJson(e.request(), "version");
+		return _e(e.parse(t));
+	}
+	async isTableExisted(e) {
+		this.#u("isTableExisted");
+		let t = r(e).name, n = this.#e.onIsTableExisted ? this.#e.onIsTableExisted.request({ entityName: t }) : this.#e.onFetchMetadata.request({
+			entityName: t,
+			where: Ie,
+			offset: 0,
+			limit: 1
+		});
+		return this.#n.execute(n, "isTableExisted", async (e) => {
+			if (e.ok || e.status === 404) return await e.body?.cancel().catch(() => void 0), e.ok;
+			let t = await K(e, this.#t.signal);
+			throw new S(e.status, this.#n.resolveUrl(n), t);
+		});
+	}
+	fetchMetadata(e, t) {
+		return s(() => (this.#u("fetchMetadata"), c(we({
+			transport: this.#n,
+			handler: this.#e.onFetchMetadata,
+			config: this.config
+		}, {
+			entityName: e,
+			where: t
+		}))));
+	}
+	findByIds(e, t) {
+		return s(() => (this.#u("findByIds"), c(me({
+			transport: this.#n,
+			handler: this.#e.onFindByIds,
+			config: this.config
+		}, {
+			entityName: e,
+			ids: t
+		})).pipe(l((e) => e))));
+	}
+	getRepository() {
+		throw new h("getRepository");
+	}
+	async saveMany() {
+		throw new h("saveMany");
+	}
+	async removeMany() {
+		throw new h("removeMany");
+	}
+	async mutations() {
+		throw new h("mutations");
+	}
+	async pullChanges() {
+		throw new p("pullChanges");
+	}
+	async getChangeCount() {
+		throw new p("getChangeCount");
+	}
+	async mergeChanges() {
+		throw new p("mergeChanges");
+	}
+	#o() {
+		return new Fe({
+			baseUrl: this.options.baseUrl,
+			requestTimeoutMs: this.config.requestTimeoutMs,
+			disconnectSignal: this.#t.signal,
+			auth: this.options.auth,
+			headers: this.options.headers,
+			reportResult: (e) => this.rxdb.reachability.report(e),
+			conditional: this.options.conditionalRequests === !0 ? {
+				maxEntries: this.config.conditionalCacheSize,
+				onEtagUnreadable: this.options.onEtagUnreadable
+			} : void 0
+		});
+	}
+	#s() {
+		let e = this.options.changeFeed;
+		if (e !== void 0) return R(e.url), new P({
+			url: this.#n.resolveUrl({
+				url: e.url,
+				method: "GET"
+			}),
+			options: e,
+			clientId: () => this.rxdb.context.clientId,
+			entities: () => this.#c(),
+			invalidate: (e, t) => this.rxdb.invalidateRemoteEntity(e, t)
+		});
+	}
+	#c() {
+		let e = [], t = /* @__PURE__ */ new Set();
+		for (let n of this.rxdb.config.entities) {
+			let i = r(n), a = $(i.name, i.namespace);
+			!t.has(a) && this.#l(n, i) && (t.add(a), e.push({
+				name: i.name,
+				namespace: i.namespace
+			}));
+		}
+		return e;
+	}
+	#l(e, t) {
+		if (o(e)) return !1;
+		let n = this.rxdb.config.sync;
+		return a(t, n) === "querycache" && i(t, n)?.remote?.adapter === "http";
+	}
+	#u(e) {
+		if (!this.#a) throw new y(e);
+	}
+	#d(e) {
+		let t = this.#r;
+		if (!t) throw new h(e, "no \"changeFeed\" is configured; there is no channel to switch on or off");
+		return t;
+	}
+	#f() {
+		let { onCreate: e, onUpdate: t, onDelete: n } = this.#e;
+		e && (this.create = (t, n) => {
+			let r = {
+				entityName: t,
+				data: n
+			};
+			return s(() => (this.#u("create"), c(this.#n.sendJson(e.request(r), "create")))).pipe(l((n) => V("create", t, e.parse(n, r))));
+		}), t && (this.update = (e, n, r) => {
+			let i = {
+				entityName: e,
+				id: n,
+				data: r
+			};
+			return s(() => (this.#u("update"), c(this.#n.sendJson(t.request(i), "update")))).pipe(l((n) => V("update", e, t.parse(n, i))));
+		}), n && (this.delete = (e, t) => s(() => {
+			this.#u("delete");
+			let r = Array.isArray(t) ? t : [t];
+			return r.length === 0 ? u(void 0) : c(this.#n.sendVoid(n.request({
+				entityName: e,
+				ids: r
+			}), "delete"));
+		}));
+	}
+	#p() {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of this.rxdb.config.entities) {
+			let n = r(t);
+			e.set($(n.name, n.namespace), n);
+		}
+		for (let t of e.values()) this.#m(t, e);
+	}
+	#m(e, t) {
+		if (i(e, this.rxdb.config.sync)?.remote?.adapter !== "http") return;
+		let n = Re(e, t);
+		if (n) throw new m(e.name, n.name, n.type);
+	}
+}, $ = (e, t) => `${t}\u0000${e}`, Re = (e, t) => {
+	for (let t of e.propertyMap.values()) if (Q.has(t.type)) return {
+		name: t.name,
+		type: t.type
+	};
+	for (let [n, r] of e.foreignKeyRelationMap) {
+		let i = t.get($(r.mappedEntity, r.mappedNamespace ?? e.namespace))?.propertyMap.get("id")?.type;
+		if (i !== void 0 && Q.has(i)) return {
+			name: n,
+			type: i
+		};
+	}
+}, ze = (e) => {
+	if (typeof e != "string" || e.trim().length === 0) throw new f("HTTP adapter config \"baseUrl\" must be a non-empty string", "baseUrl", e);
+}, Be = (e) => {
+	for (let t of ["onFetchMetadata", "onFindByIds"]) if (!e?.[t]) throw new f(`HTTP adapter config "handlers.${t}" is required`, `handlers.${t}`, e?.[t]);
+};
+//#endregion
+export { Z as ADAPTER_NAME, C as DEFAULT_HTTP_CONFIG, d as HttpAdapterError, p as HttpChangelogUnsupportedError, f as HttpConfigError, y as HttpDisconnectedError, g as HttpHandlerContractError, v as HttpInvalidMetadataError, b as HttpInvalidResponseError, _ as HttpPaginationError, x as HttpRequestBuildError, S as HttpResponseError, h as HttpUnsupportedOperationError, m as HttpUnsupportedWireTypeError, Le as RxDBAdapterHttp, ue as createRestHandlers };