🚀 Socket Launch Week Day 5:Introducing Repository Access Permissions and Custom Roles.Learn more →

@nxtedition/couch

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@nxtedition/couch - npm Package Compare versions

Comparing version

1.1.51

2.0.0

+1

lib/index.d.ts.map

+1

lib/index.js.map

+36

lib/request.d.ts

		import stream from 'node:stream';
		import type { Dispatcher, LoggerLike, RequestOptions, URLObject } from '@nxtedition/nxt-undici';
		import type { Priority } from './utils.ts';
		export interface CouchResponse<T = unknown> {
		rows: T[];
		total_rows?: number;
		offset?: number \| null;
		update_seq?: string;
		}
		export interface CouchRequestOptions<Stream extends boolean = boolean> {
		id?: string;
		url?: string \| URL \| URLObject;
		pathname?: string;
		path?: string;
		origin?: string;
		headers?: Record<string, string \| string[] \| null \| undefined> \| null;
		method?: string;
		body?: unknown;
		query?: Record<string, unknown> \| null;
		headersTimeout?: number \| null;
		bodyTimeout?: number \| null;
		dispatcher?: Dispatcher \| null;
		priority?: Priority \| null;
		blocking?: boolean \| null;
		idempotent?: boolean \| null;
		retry?: RequestOptions['retry'];
		dns?: RequestOptions['dns'];
		cache?: RequestOptions['cache'];
		signal?: AbortSignal \| null;
		logger?: LoggerLike \| null;
		highWaterMark?: number;
		stream?: Stream;
		}
		export declare function request<T = unknown, Stream extends boolean = false>(url: string \| URL \| URLObject, opts?: CouchRequestOptions<Stream> \| null): Stream extends true ? stream.Readable : Promise<T>;
		export declare function request<T = unknown, Stream extends boolean = false>(opts: CouchRequestOptions<Stream>): Stream extends true ? stream.Readable : Promise<T>;
		//# sourceMappingURL=request.d.ts.map

+1

lib/request.d.ts.map

{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,aAAa,CAAA;AAGhC,OAAO,KAAK,EAGV,UAAU,EACV,UAAU,EACV,cAAc,EACd,SAAS,EACV,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAmN1C,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO;IACxC,IAAI,EAAE,CAAC,EAAE,CAAA;IACT,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,mBAAmB,CAAC,MAAM,SAAS,OAAO,GAAG,OAAO;IACnE,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAAA;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,IAAI,CAAA;IACrE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IACtC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC9B,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IACzB,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAC3B,KAAK,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAA;IAC/B,GAAG,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,CAAA;IAC3B,KAAK,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAA;IAC3B,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAQD,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,SAAS,OAAO,GAAG,KAAK,EACjE,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,EAC7B,IAAI,CAAC,EAAE,mBAAmB,CAAC,MAAM,CAAC,GAAG,IAAI,GACxC,MAAM,SAAS,IAAI,GAAG,MAAM,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AACrD,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,SAAS,OAAO,GAAG,KAAK,EACjE,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,GAChC,MAAM,SAAS,IAAI,GAAG,MAAM,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA"}

+283

lib/request.js

		import assert from 'node:assert';
		import net from 'node:net';
		import stream from 'node:stream';
		import { dispatch, Agent } from '@nxtedition/nxt-undici';
		import { AbortError } from '@nxtedition/error';
		class StreamOutput extends stream.Readable {
		#str = '';
		#resume;
		#abort;
		#state;
		#decoder;
		#headers;
		constructor({ signal, highWaterMark = 256, }) {
		super({ objectMode: true, highWaterMark, signal: signal ?? undefined });
		}
		get headers() {
		return this.#headers;
		}
		_read() {
		this.#resume?.();
		}
		_destroy(err, callback) {
		this.#abort?.(err ?? undefined);
		callback(err);
		}
		onConnect(abort) {
		if (this.destroyed) {
		abort(this.errored ?? undefined);
		}
		else if (this.#state) {
		throw new Error('unusable');
		}
		else {
		this.#state = 0;
		this.#str = '';
		this.#abort = abort;
		this.#decoder = new TextDecoder();
		}
		}
		onHeaders(statusCode, headers, resume) {
		if (statusCode >= 300 \|\| statusCode < 200) {
		throw Object.assign(new Error('invalid status code: ' + statusCode), { statusCode, headers });
		}
		this.#headers = headers;
		this.#resume = resume;
		}
		onData(data) {
		const lines = this.#decoder.decode(data, { stream: true }).split(/\r?\n+/);
		lines[0] = this.#str + lines[0];
		this.#str = lines.pop() ?? '';
		try {
		let ret = true;
		for (const line of lines) {
		if (!line) {
		continue;
		}
		if (this.#state === 0) {
		if (/\[\s*$/.test(line)) {
		this.#state = 1;
		}
		else {
		throw new Error('expected [ at end of line');
		}
		}
		else if (this.#state === 1) {
		if (/^\s*\]/.test(line)) {
		this.#state = 2;
		}
		else {
		const row = JSON.parse(line.slice(0, line.lastIndexOf('}') + 1));
		if (!this.push(row)) {
		ret = false;
		}
		}
		}
		}
		return ret;
		}
		catch (err) {
		throw Object.assign(new Error('invalid data'), {
		data: lines.join('\n') + this.#str,
		cause: err,
		});
		}
		}
		onComplete() {
		// A thrown assert here would be swallowed: nxt-undici treats the dispatch
		// as settled once onComplete is entered, so the stream would neither end
		// nor error — a permanent hang for the consumer. Destroy with a parse
		// error instead when the body ended before the rows trailer.
		const tail = this.#str + (this.#decoder ? this.#decoder.decode() : '');
		if (this.#state === 1 && /^\s*\]/.test(tail)) {
		this.#state = 2;
		}
		if (this.#state !== 2) {
		this.destroy(Object.assign(new Error('invalid data'), { data: tail }));
		return;
		}
		this.push(null);
		}
		onError(err) {
		this.destroy(err);
		}
		}
		class PromiseOutput {
		#resolve;
		#reject;
		#str = '';
		#decoder;
		#signal;
		#abort;
		constructor({ resolve, reject, signal, }) {
		this.#resolve = resolve;
		this.#reject = reject;
		this.#signal = signal;
		}
		onConnect(abort) {
		this.#decoder = new TextDecoder();
		this.#str = '';
		const signal = this.#signal;
		if (signal?.aborted) {
		abort(signal.reason ?? new AbortError());
		}
		else if (signal) {
		if (this.#abort) {
		// A retried request calls onConnect again; drop the stale listener so
		// it does not accumulate for every attempt.
		signal.removeEventListener('abort', this.#abort);
		}
		// Wrap the undici abort callback: registering it directly would invoke
		// it with the 'abort' Event object, which then propagates as the
		// rejection "error".
		this.#abort = () => {
		abort(signal.reason ?? new AbortError());
		};
		signal.addEventListener('abort', this.#abort);
		}
		}
		onHeaders(statusCode, rawHeaders, resume) {
		if (statusCode >= 300 \|\| statusCode < 200) {
		throw Object.assign(new Error('invalid status code: ' + statusCode), {
		statusCode,
		headers: rawHeaders,
		});
		}
		}
		onData(data) {
		this.#str += this.#decoder.decode(data, { stream: true });
		}
		onComplete() {
		this.#str += this.#decoder.decode(undefined, { stream: false });
		try {
		this.#onDone(null, JSON.parse(this.#str));
		}
		catch (err) {
		this.#onDone(Object.assign(new Error('invalid json'), { data: this.#str, cause: err }));
		}
		}
		onError(err) {
		this.#onDone(err);
		}
		#onDone(err, val) {
		if (err) {
		this.#reject(err);
		}
		else {
		this.#resolve(val);
		}
		if (this.#abort) {
		this.#signal?.removeEventListener('abort', this.#abort);
		}
		}
		}
		const defaultDispatcher = new Agent({
		// pipelining: 4,
		connections: 8 * 4,
		connectTimeout: 2e3,
		});
		const blockingDispatcher = new Agent({
		pipelining: 1,
		connections: 1024,
		connectTimeout: 2e3,
		});
		export function request(url, opts) {
		let urlLike;
		if (typeof url === 'string') {
		opts = { url: new URL(url), ...opts };
		}
		else if (url instanceof URL) {
		opts = { url, ...opts };
		}
		else if (url != null &&
		typeof (url.path ?? url.pathname) === 'string' &&
		(typeof url.origin === 'string' \|\|
		url.host != null \|\|
		url.hostname != null)) {
		// A bare URL-like object ({ origin, path \| pathname }); it may also carry
		// request options when used in the opts-only calling convention.
		urlLike = url;
		opts = opts
		? { ...url, ...opts }
		: url;
		}
		if (opts == null && typeof url === 'object' && url != null) {
		opts = url;
		}
		assert(opts != null, 'invalid arguments');
		urlLike = opts.url ?? urlLike;
		if (typeof urlLike === 'string') {
		urlLike = new URL(urlLike);
		}
		assert(urlLike != null, 'invalid url');
		let origin = urlLike.origin;
		if (!origin) {
		const protocol = urlLike.protocol ?? 'http:';
		const rawHostname = urlLike.hostname;
		// IPv6 literals must be bracketed in the authority or URL parsing fails.
		const hostname = rawHostname != null && net.isIPv6(rawHostname) ? `[${rawHostname}]` : rawHostname;
		const host = urlLike.host ??
		`${hostname}:${urlLike.port ?? (protocol === 'https:' ? 443 : 80)}`;
		origin = `${protocol}//${host}`;
		}
		let path = urlLike.path;
		if (!path) {
		const { pathname, search } = urlLike;
		path = search ? `${pathname}${search}` : pathname;
		}
		// Only plain JSON values are serialized — Buffers, TypedArrays,
		// ArrayBuffers and streams must pass through untouched or binary uploads
		// would be corrupted into their JSON object representation.
		const isJsonBody = opts.body != null &&
		typeof opts.body === 'object' &&
		!Buffer.isBuffer(opts.body) &&
		!ArrayBuffer.isView(opts.body) &&
		!(opts.body instanceof ArrayBuffer) &&
		typeof opts.body.pipe !== 'function';
		const ureq = {
		...opts,
		dns: opts.dns !== false && opts.dns !== null
		? {
		balance: 'hash',
		...(typeof opts.dns === 'object' ? opts.dns : null),
		}
		: opts.dns,
		origin,
		path,
		// Presence, not truthiness: a valid falsy body ('', 0, false, empty
		// Buffer) must still default to POST rather than GET-with-a-body.
		method: opts.method ?? (opts.body != null ? 'POST' : 'GET'),
		blocking: opts.blocking ?? Boolean(opts.stream),
		headers: {
		'content-type': isJsonBody ? 'application/json' : 'text/plain',
		accept: 'application/json',
		// Lowercase caller header names so they override the defaults above —
		// a spread of e.g. 'Content-Type' would otherwise ride along as a
		// second, differently-cased content-type header on the wire.
		...(opts.headers
		? Object.fromEntries(Object.entries(opts.headers).map(([k, v]) => [k.toLowerCase(), v]))
		: null),
		},
		cache: opts.cache ?? false,
		body: isJsonBody ? JSON.stringify(opts.body) : opts.body,
		};
		const dispatcher = opts.dispatcher ?? (ureq.blocking ? blockingDispatcher : defaultDispatcher);
		const signal = opts.signal;
		if (opts.stream) {
		const handler = new StreamOutput({ signal, highWaterMark: opts.highWaterMark });
		void dispatch(dispatcher, ureq, handler);
		return handler;
		}
		else {
		return new Promise((resolve, reject) => {
		const handler = new PromiseOutput({ resolve, reject, signal });
		void dispatch(dispatcher, ureq, handler);
		});
		}
		}
		;
		globalThis.__nxt_lib_couch = {
		request,
		defaultDispatcher,
		};
		//# sourceMappingURL=request.js.map

+1

lib/request.js.map

+15

lib/utils.d.ts

		import type { DispatchOptions } from '@nxtedition/nxt-undici';
		export type Priority = NonNullable<DispatchOptions['priority']>;
		export interface AbortSignalLike {
		aborted?: boolean;
		reason?: unknown;
		on?(event: 'abort', listener: () => void): void;
		off?(event: 'abort', listener: () => void): void;
		addEventListener?(event: 'abort', listener: () => void): void;
		removeEventListener?(event: 'abort', listener: () => void): void;
		addListener?(event: 'abort', listener: () => void): void;
		removeListener?(event: 'abort', listener: () => void): void;
		}
		export declare function addAbortListener(signal: AbortSignalLike, listener: () => void): void;
		export declare function removeAbortListener(signal: AbortSignalLike, listener: () => void): void;
		//# sourceMappingURL=utils.d.ts.map

+1

lib/utils.d.ts.map

{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAI7D,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAA;AAK/D,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAC/C,GAAG,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAChD,gBAAgB,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAC7D,mBAAmB,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAChE,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IACxD,cAAc,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CAC5D;AAKD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAQpF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAQvF"}

+26

lib/utils.js

		// Registration/removal for AbortSignalLike. The probe orders mirror each
		// other so a listener is always removed through the same style it was added
		// with (EventEmitters alias on/addListener and off/removeListener).
		export function addAbortListener(signal, listener) {
		if (signal.addEventListener) {
		signal.addEventListener('abort', listener);
		}
		else if (signal.on) {
		signal.on('abort', listener);
		}
		else if (signal.addListener) {
		signal.addListener('abort', listener);
		}
		}
		export function removeAbortListener(signal, listener) {
		if (signal.removeEventListener) {
		signal.removeEventListener('abort', listener);
		}
		else if (signal.off) {
		signal.off('abort', listener);
		}
		else if (signal.removeListener) {
		signal.removeListener('abort', listener);
		}
		}
		//# sourceMappingURL=utils.js.map

+1

lib/utils.js.map

{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAoBA,yEAAyE;AACzE,4EAA4E;AAC5E,oEAAoE;AACpE,MAAM,UAAU,gBAAgB,CAAC,MAAuB,EAAE,QAAoB;IAC5E,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAC5B,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC5C,CAAC;SAAM,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;QACrB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC9B,CAAC;SAAM,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;QAC9B,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IACvC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAuB,EAAE,QAAoB;IAC/E,IAAI,MAAM,CAAC,mBAAmB,EAAE,CAAC;QAC/B,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC/C,CAAC;SAAM,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;QACtB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC/B,CAAC;SAAM,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;QACjC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC1C,CAAC;AACH,CAAC"}

+153

-129

lib/index.d.ts

		@@ -1,139 +0,163 @@
		import type { Logger } from '@nxtedition/logger'
		import type { Readable } from 'node:stream'
		import type { Dispatcher } from 'undici'
		import type { Priority } from '@nxtedition/scheduler'

		export interface CouchOptions {
		url?: string
		import type { Dispatcher, LoggerLike } from '@nxtedition/nxt-undici';
		import { type AbortSignalLike, type Priority } from './utils.ts';
		export type { AbortSignalLike } from './utils.ts';
		export { request } from './request.ts';
		export type { CouchResponse, CouchRequestOptions } from './request.ts';
		export interface CouchConfig {
		url?: string \| string[];
		name?: string;
		userAgent?: string;
		getClient?: (pathname: string) => Dispatcher;
		couchdb?: CouchOptions;
		couch?: CouchOptions;
		config?: CouchConfig;
		}

		export function makeCouch(opts: string \| CouchOptions): CouchClient

		export interface CouchRequestOptions<Stream extends boolean = false> {
		id?: string
		url?: URL
		pathname?: string
		path?: string
		headers?: Record<string, string>
		method?: string
		body?: unknown
		headersTimeout?: number
		bodyTimeout?: number
		dispatcher?: Dispatcher
		priority?: Priority
		query?: {
		key?: string
		startkey?: string
		endkey?: string
		update?: boolean
		seq?: string
		}
		blocking?: boolean
		seq?: string
		signal?: AbortSignal
		logger?: Logger
		stream?: Stream
		// TODO add more or extend undicii type?
		export type CouchOptions = string \| string[] \| CouchConfig;
		export interface CouchCallOptions {
		client?: Dispatcher;
		signal?: AbortSignalLike \| null;
		idempotent?: boolean;
		headers?: Record<string, string> \| string[] \| null;
		}

		export interface CouchResponse<T> {
		rows: T[]
		export interface CouchClientRequestOptions extends CouchCallOptions {
		params?: Record<string, unknown> \| null;
		body?: unknown;
		method?: string;
		}

		export function request<T, Stream extends boolean = false>(
		url: string \| URL \| { origin: string; path?: string; pathname?: string },
		opts?: CouchRequestOptions<Stream> \| null,
		): Stream extends true ? Readable : Promise<CouchResponse<T>>

		interface ChangesOptions {
		signal?: AbortSignal \| null
		descending?: boolean
		include_docs?: boolean
		seq_interval?: number \| null
		live?: boolean
		heartbeat?: number
		retry?: (
		err: unknown,
		retryCount: number,
		params: {
		since?: string \| 0 \| null
		},
		ac: { signal: AbortSignal },
		next: () => void,
		) => void \| null \| Promise<void>
		since?: string \| 0 \| null
		selector?: object \| null
		highWaterMark?: number
		priority?: Priority
		export interface CouchRequestResult<T = unknown> {
		data: T;
		status: number;
		headers: Record<string, string \| string[]>;
		}

		interface ChangeItem {
		id: string
		seq?: string
		doc?: object
		deleted?: boolean
		changes: Array<{ rev: string }>
		export interface ChangeItem {
		id: string;
		seq?: string \| null;
		doc?: Record<string, unknown> \| null;
		deleted?: boolean;
		changes: Array<{
		rev: string;
		}>;
		}

		export interface AllDocsOptions {
		client?: unknown
		signal?: AbortSignal
		idempotent?: boolean
		conflicts?: boolean
		update_seq?: boolean
		descending?: boolean
		include_docs?: boolean
		sorted?: boolean
		key?: string
		keys?: string[]
		startkey?: string
		start_key?: string
		startkey_docid?: string
		endkey?: string
		end_key?: string
		endkey_docid?: string
		inclusive_end?: boolean
		limit?: number
		skip?: number
		stale?: string
		reduce?: boolean
		stable?: boolean
		update?: boolean
		group?: boolean
		group_level?: number
		export type ChangeBatch = ChangeItem[] & {
		lastSeq?: string \| 0 \| null;
		};
		export interface ChangesRetryState {
		since: string \| 0 \| null \| undefined;
		time: number;
		count: number;
		}

		// A _all_docs row is either a found row (id/value/doc present) or, in `keys`
		// mode, an error row for a key that does not exist (`{ key, error }`, no doc).
		// With include_docs a deleted doc has `doc: null`.
		export interface AllDocsRow<Doc = Record<string, unknown>> {
		id?: string
		key: string
		value?: { rev: string; deleted?: boolean }
		doc?: Doc \| null
		error?: string
		export type ChangesRetryFn = (err: unknown, retryCount: number, state: ChangesRetryState, ctx: {
		signal: AbortSignal;
		logger?: LoggerLike \| null;
		}, next: () => boolean \| Promise<boolean>) => unknown;
		export interface ChangesOptions {
		client?: Dispatcher;
		signal?: AbortSignalLike \| null;
		logger?: LoggerLike \| null;
		conflicts?: boolean;
		descending?: boolean;
		include_docs?: boolean;
		seq_interval?: number \| null;
		/** Start sequence. Mutated retry state is reported per batch via `lastSeq`. */
		since?: string \| 0 \| null;
		until?: string \| null;
		style?: string;
		view?: string;
		filter?: string;
		/** Continuous-feed heartbeat interval in milliseconds. Defaults to 60000. */
		heartbeat?: number;
		timeout?: number;
		limit?: number;
		doc_ids?: string[];
		selector?: object \| null;
		/** Defaults to `true` (continuous feed) when omitted. */
		live?: boolean;
		retry?: ChangesRetryFn \| null;
		highWaterMark?: number;
		priority?: Priority \| null;
		}

		export interface AllDocsResponse<Doc = Record<string, unknown>> {
		total_rows?: number
		offset?: number \| null
		update_seq?: string
		rows: Array<AllDocsRow<Doc>>
		export interface AllDocsOptions extends Omit<CouchCallOptions, 'headers'> {
		conflicts?: boolean;
		update_seq?: boolean;
		descending?: boolean;
		include_docs?: boolean;
		sorted?: boolean;
		key?: unknown;
		keys?: unknown[];
		startkey?: unknown;
		start_key?: unknown;
		startkey_docid?: string;
		endkey?: unknown;
		end_key?: unknown;
		endkey_docid?: string;
		inclusive_end?: boolean;
		limit?: number;
		skip?: number;
		stale?: string;
		reduce?: boolean;
		stable?: boolean;
		update?: boolean \| string;
		group?: boolean;
		group_level?: number;
		}

		export interface AllDocsRow<Doc = Record<string, unknown>, Value = {
		rev: string;
		deleted?: boolean;
		}> {
		id?: string;
		key: unknown;
		value?: Value;
		doc?: Doc \| null;
		error?: string;
		}
		export interface AllDocsResponse<Doc = Record<string, unknown>, Value = {
		rev: string;
		deleted?: boolean;
		}> {
		total_rows?: number;
		offset?: number \| null;
		update_seq?: string;
		rows: Array<AllDocsRow<Doc, Value>>;
		}
		export interface BulkDocsResultItem {
		ok?: boolean;
		id: string;
		rev?: string;
		error?: string;
		reason?: string;
		}
		export interface UpsertResult<Doc = Record<string, unknown>> {
		updated: boolean;
		id?: string;
		rev?: string;
		ok?: boolean;
		doc: Doc;
		}
		export interface CouchClient {
		changes: (
		options?: ChangesOptions & { client?: unknown; logger?: Logger },
		) => AsyncGenerator<ChangeItem[] & { lastSeq?: string \| 0 \| null }, void, unknown>
		allDocs: <Doc = Record<string, unknown>>(options: AllDocsOptions) => Promise<AllDocsResponse<Doc>>
		allDocs: <Doc = Record<string, unknown>>(
		pathname: string,
		options?: AllDocsOptions,
		) => Promise<AllDocsResponse<Doc>>
		allDocs: <Doc = Record<string, unknown>>(
		pathnameOrOptions?: string \| AllDocsOptions,
		options?: AllDocsOptions,
		) => Promise<AllDocsResponse<Doc>>
		up: (opts?: { client?: unknown; signal?: AbortSignal }) => Promise<unknown>
		close: () => Promise<void>
		url: URL;
		request<T = unknown>(url: string \| null, opts: CouchClientRequestOptions): Promise<CouchRequestResult<T>>;
		bulkDocs<T = unknown>(body: {
		docs: T[];
		new_edits?: boolean;
		}, opts?: CouchCallOptions): Promise<BulkDocsResultItem[]>;
		allDocs<Doc = Record<string, unknown>>(options?: AllDocsOptions): Promise<AllDocsResponse<Doc>>;
		allDocs<Doc = Record<string, unknown>>(pathname: string \| null, options?: AllDocsOptions): Promise<AllDocsResponse<Doc>>;
		put<T = unknown>(pathname: string \| null, params?: Record<string, unknown> \| null, body?: unknown, opts?: CouchCallOptions): Promise<T>;
		post<T = unknown>(pathname: string \| null, params?: Record<string, unknown> \| null, body?: unknown, opts?: CouchCallOptions): Promise<T>;
		get<T = unknown>(pathname: string \| null, params?: Record<string, unknown> \| null, body?: unknown, opts?: CouchCallOptions): Promise<T>;
		delete<T = unknown>(pathname: string \| null, params?: Record<string, unknown> \| null, body?: unknown, opts?: CouchCallOptions): Promise<T>;
		info<T = Record<string, unknown>>(params?: Record<string, unknown> \| null, body?: unknown, opts?: CouchCallOptions): Promise<T>;
		upsert<Doc = Record<string, unknown>>(pathname: string, diffFun: (doc: Doc) => Doc \| null \| undefined \| false, opts?: {
		client?: Dispatcher;
		signal?: AbortSignalLike \| null;
		}): Promise<UpsertResult<Doc>>;
		changes(options?: ChangesOptions): AsyncGenerator<ChangeBatch, void, unknown>;
		up(opts?: {
		client?: Dispatcher;
		signal?: AbortSignal \| null;
		}): Promise<unknown>;
		close(): Promise<void>;
		}
		export declare const CHANGES_RETRYABLE_ERROR_CODES: readonly string[];
		export declare function makeCouch(opts: CouchOptions): CouchClient;
		//# sourceMappingURL=index.d.ts.map

+827

-1183

lib/index.js

		@@ -1,1238 +0,882 @@
		import assert from 'node:assert'
		import stream from 'node:stream'
		import querystring from 'node:querystring'
		import tp from 'node:timers/promises'

		import createError from 'http-errors'
		import urljoin from 'url-join'
		import urlJoin from 'url-join'

		import { dispatch, Agent, Pool, request as undiciRequest } from '@nxtedition/nxt-undici'
		import { makeWeakCache } from '@nxtedition/weak-cache'

		import { AbortError } from '@nxtedition/error'

		/**
		* @typedef {import('@nxtedition/scheduler').Priority} Priority
		*/

		import assert from 'node:assert';
		import querystring from 'node:querystring';
		import tp from 'node:timers/promises';
		import createError from 'http-errors';
		import urlJoin from 'url-join';
		import { dispatch, Pool, request as undiciRequest } from '@nxtedition/nxt-undici';
		import { makeWeakCache } from '@nxtedition/weak-cache';
		import { AbortError } from '@nxtedition/error';
		import { addAbortListener, removeAbortListener, } from "./utils.js";
		export { request } from "./request.js";
		// Transport-level error codes the default changes() retry treats as
		// reconnectable. Exported so custom retry callbacks can reuse the list.
		export const CHANGES_RETRYABLE_ERROR_CODES = Object.freeze([
		'ECONNRESET',
		'ECONNREFUSED',
		'ENOTFOUND',
		'ENETDOWN',
		'ENETUNREACH',
		'EHOSTDOWN',
		'EHOSTUNREACH',
		'EPIPE',
		'EAI_AGAIN',
		'ENODATA',
		'UND_ERR_CONNECT_TIMEOUT',
		'UND_ERR_SOCKET',
		// The whole point of bodyTimeout = 2 * heartbeat (and the fixed 2-minute
		// headersTimeout) is to detect a silently dead connection (no FIN/RST);
		// reconnecting from params.since is the loop's normal recovery path, and the
		// 2-minute give-up still bounds persistent failure.
		'UND_ERR_BODY_TIMEOUT',
		'UND_ERR_HEADERS_TIMEOUT',
		]);
		export function makeCouch(opts) {
		let config
		if (typeof opts === 'string') {
		config = opts
		} else if (Array.isArray(opts)) {
		config = opts
		} else if (opts?.url) {
		config = opts
		} else if (opts?.couchdb \|\| opts?.couch) {
		config = opts.couchdb \|\| opts.couch
		} else if (opts?.config) {
		config = opts.config.couchdb \|\| opts.config.couch \|\| opts.config
		} else {
		throw new Error('invalid options')
		}

		if (typeof config === 'string') {
		config = { url: config }
		}

		if (!config.url && config.name) {
		config = { ...config, url: config.name }
		}

		const { origin: dbOrigin, pathname: dbPathname } = new URL(
		Array.isArray(config.url) ? config.url[0] : config.url,
		)

		const defaultClientOpts = {
		connectTimeout: 2e3,
		}

		const userAgent = config.userAgent \|\| globalThis.userAgent
		const defaultClient = new Pool(dbOrigin, defaultClientOpts)

		const getClient =
		config.getClient ??
		makeWeakCache(
		() =>
		new Pool(dbOrigin, {
		...defaultClientOpts,
		connections: 4, // TODO (fix): Global limit?
		pipelining: 2,
		}),
		)

		function makeError(req, res) {
		let path

		if (req.path) {
		path = req.path
		} else {
		path = dbPathname
		if (req.pathname) {
		path = urljoin(path, req.pathname)
		}
		if (req.params) {
		path += `?${querystring.stringify(req.params)}`
		}
		let config;
		if (typeof opts === 'string' \|\| Array.isArray(opts)) {
		config = opts;
		}

		let reason
		let error
		try {
		const json = typeof res.data === 'string' ? JSON.parse(res.data) : res.data
		reason = json.reason
		error = json.error
		} catch {
		// Do nothing...
		else if (opts?.url) {
		config = opts;
		}

		return createError(res.status, {
		reason,
		error,
		data: {
		req: {
		origin: dbOrigin,
		path,
		method: req.method,
		headers: req.headers,
		body: req.body ? JSON.stringify(req.body).slice(0, 4096) : null,
		},
		res: {
		status: res.status,
		headers: res.headers,
		body: res.data,
		},
		},
		})
		}

		/**
		* @param {Object} [options={}]
		* @param {AbortSignal} [options.signal]
		* @param {boolean} [options.descending=false]
		* @param {boolean} [options.include_docs=false]
		* @param {number} [options.seq_interval=null]
		* @param {boolean} [options.live=false]
		* @param {number} [options.heartbeat=60000]
		* @param {function} [options.retry=null]
		* @param {0\|string\|null} [options.since=null]
		* @param {object} [options.selector=null]
		* @param {number} [options.highWaterMark=128 * 1024]
		* @param {Priority} [options.priority=null]
		* @param {import('pino').Logger} [options.logger=null]
		* @return {AsyncGenerator<Array<{ id: string, seq?: string, doc?: Object, deleted?: boolean, changes: Array<{ rev: string }>}> & { lastSeq: string \| null \| 0 }}
		*/
		async function* changes({ client = defaultClient, signal, logger, ...options } = {}) {
		const params = {}

		let body
		let method = 'GET'

		if (options.conflicts) {
		params.conflicts = true
		else if (opts?.couchdb \|\| opts?.couch) {
		config = (opts.couchdb \|\| opts.couch);
		}

		if (options.descending) {
		params.descending = true
		else if (opts?.config) {
		config = opts.config.couchdb \|\| opts.config.couch \|\| opts.config;
		}

		if (options.include_docs) {
		params.include_docs = true
		else {
		throw new Error('invalid options');
		}

		if (options.seq_interval != null) {
		params.seq_interval = options.seq_interval
		if (typeof config === 'string' \|\| Array.isArray(config)) {
		config = { url: config };
		}

		if (options.since != null) {
		params.since = options.since
		if (!config.url && config.name) {
		config = { ...config, url: config.name };
		}

		if (options.until != null) {
		params.until = options.until
		// Validate before constructing: an empty url array (or empty string) would
		// otherwise surface as a low-signal 'Invalid URL' TypeError.
		const dbUrl = Array.isArray(config.url) ? config.url[0] : config.url;
		if (!dbUrl) {
		throw new Error('invalid options');
		}

		if (options.style != null) {
		params.style = options.style
		const { origin: dbOrigin, pathname: dbPathname } = new URL(dbUrl);
		const defaultClientOpts = {
		connectTimeout: 2e3,
		};
		const userAgent = config.userAgent \|\| globalThis.userAgent;
		const defaultClient = new Pool(dbOrigin, defaultClientOpts);
		const getClient = config.getClient ??
		makeWeakCache((_pathname) => new Pool(dbOrigin, {
		...defaultClientOpts,
		connections: 4, // TODO (fix): Global limit?
		pipelining: 2,
		}));
		function makeError(req, res) {
		let path;
		if (req.path) {
		path = req.path;
		}
		else {
		path = dbPathname;
		if (req.pathname) {
		path = urlJoin(path, req.pathname);
		}
		if (req.params) {
		path += `?${querystring.stringify(req.params)}`;
		}
		}
		let reason;
		let error;
		try {
		const json = (typeof res.data === 'string' ? JSON.parse(res.data) : res.data);
		reason = json.reason;
		error = json.error;
		}
		catch {
		// Do nothing...
		}
		return createError(res.status, {
		reason,
		error,
		data: {
		req: {
		origin: dbOrigin,
		path,
		method: req.method,
		headers: req.headers,
		// req.body is usually already a serialized JSON string; stringifying
		// again would quote/escape it and make log payloads harder to read.
		body: req.body != null
		? (typeof req.body === 'string' ? req.body : JSON.stringify(req.body)).slice(0, 4096)
		: null,
		},
		res: {
		status: res.status,
		headers: res.headers,
		body: res.data,
		},
		},
		});
		}

		if (options.view != null) {
		params.view = options.view
		}

		if (options.filter != null) {
		params.filter = options.filter
		}

		if (options.heartbeat != null) {
		params.heartbeat = Number(options.heartbeat)
		} else {
		params.heartbeat = 60e3
		}

		if (options.timeout != null) {
		params.timeout = options.timeout
		}

		if (options.limit != null) {
		params.limit = options.limit
		}

		if (options.doc_ids != null) {
		method = 'POST'
		body = { ...body, doc_ids: options.doc_ids }
		params.filter = '_doc_ids'
		}

		if (options.selector != null) {
		method = 'POST'
		body = { ...body, selector: options.selector }
		params.filter = '_selector'
		}

		if (dbPathname === '/') {
		throw new Error('invalid pathname')
		}

		const ac = new AbortController()
		const onAbort = () => {
		ac.abort()
		}

		if (signal) {
		if (signal.aborted) {
		throw signal.reason ?? new AbortError()
		}

		if (signal.on) {
		signal.on('abort', onAbort)
		} else if (signal.addEventListener) {
		signal.addEventListener('abort', onAbort)
		}
		}

		const highWaterMark = options.highWaterMark \|\| 128 * 1024
		const live = options.live == null \|\| !!options.live
		const retry =
		options.retry ??
		(async (err, retryCount, params, { signal, logger }, next) => {
		logger?.error({ err, retryCount, params }, 'changes error')
		return next()
		})
		const priority = options.priority ?? null

		try {
		yield* _changes({
		method,
		live,
		retry,
		highWaterMark,
		params,
		body,
		signal: ac.signal,
		client,
		logger,
		priority,
		})
		} finally {
		ac.abort()
		if (signal) {
		if (signal.off) {
		signal.off('abort', onAbort)
		} else if (signal.removeEventListener) {
		signal.removeEventListener('abort', onAbort)
		async function* changes({ client = defaultClient, signal, logger, ...options } = {}) {
		const params = {};
		let body;
		let method = 'GET';
		if (options.conflicts) {
		params.conflicts = true;
		}
		}
		if (options.descending) {
		params.descending = true;
		}
		if (options.include_docs) {
		params.include_docs = true;
		}
		if (options.seq_interval != null) {
		params.seq_interval = options.seq_interval;
		}
		if (options.since != null) {
		params.since = options.since;
		}
		if (options.until != null) {
		params.until = options.until;
		}
		if (options.style != null) {
		params.style = options.style;
		}
		if (options.view != null) {
		params.view = options.view;
		}
		if (options.filter != null) {
		params.filter = options.filter;
		}
		// CouchDB only applies the `view` param when filter=_view is set; without
		// it the feed is silently unfiltered.
		if (params.view != null) {
		params.filter ??= '_view';
		}
		if (options.heartbeat != null) {
		params.heartbeat = Number(options.heartbeat);
		}
		else {
		params.heartbeat = 60e3;
		}
		if (options.timeout != null) {
		params.timeout = options.timeout;
		}
		if (options.limit != null) {
		params.limit = options.limit;
		}
		if (options.doc_ids != null) {
		method = 'POST';
		body = { ...body, doc_ids: options.doc_ids };
		params.filter = '_doc_ids';
		}
		if (options.selector != null) {
		method = 'POST';
		body = { ...body, selector: options.selector };
		params.filter = '_selector';
		}
		if (dbPathname === '/') {
		throw new Error('invalid pathname');
		}
		const ac = new AbortController();
		const onAbort = () => {
		// Forward the caller's abort reason so downstream rejections match it
		// (undefined falls back to the default AbortError).
		ac.abort(signal?.reason);
		};
		if (signal) {
		if (signal.aborted) {
		throw signal.reason ?? new AbortError();
		}
		addAbortListener(signal, onAbort);
		}
		const highWaterMark = options.highWaterMark \|\| 128 * 1024;
		const live = options.live == null \|\| !!options.live;
		const retry = options.retry ??
		(async (err, retryCount, params, { logger }, next) => {
		logger?.error({ err, retryCount, params }, 'changes error');
		return next();
		});
		const priority = options.priority ?? null;
		try {
		yield* _changes({
		method,
		live,
		retry,
		highWaterMark,
		params,
		body,
		signal: ac.signal,
		client,
		logger,
		priority,
		});
		}
		finally {
		ac.abort();
		if (signal) {
		removeAbortListener(signal, onAbort);
		}
		}
		}
		}

		async function* _changes({
		live,
		retry,
		params,
		method,
		body,
		signal,
		client,
		logger,
		highWaterMark = 128 * 1024,
		blocking = live \|\| !params.limit \|\| params.limit > 256,
		priority,
		}) {
		const startSeq = params.since \|\| null
		// NOTE: Pass the URL as the first argument and the dispatcher in the options
		// object so nxt-undici uses the configured `client` instead of the ambient
		// global dispatcher (which may be Node's built-in undici, whose handler
		// interface is incompatible). See `up()` for the same pattern.
		const { update_seq: updateSeq } = await undiciRequest(new URL(dbPathname, dbOrigin), {
		signal,
		dispatcher: client,
		}).then((res) => res.body.json())

		let retryCount = 0
		let retryTime = 0
		while (true) {
		let src
		try {
		const query = { ...params, feed: live ? 'continuous' : 'normal' }

		// NOTE: URL as the first argument, everything else (including the
		// dispatcher) in the options object — see the update_seq probe above.
		const ures = await undiciRequest(new URL(urlJoin(dbPathname, '/_changes'), dbOrigin), {
		query,
		headers: body
		? {
		'content-type': 'application/json',
		}
		: null,
		blocking,
		method,
		body: JSON.stringify(body),
		retry: false,
		idempotent: false,
		signal,
		headersTimeout: 2 * 60e3,
		bodyTimeout: 2 * (params.heartbeat \|\| 60e3),
		highWaterMark,
		dispatcher: client,
		logger,
		priority,
		})

		retryCount = 0
		retryTime = 0

		src = ures.body

		const changes = []

		let resume = null
		let error = null
		let ended = false
		let state = 0
		let since = params.since \|\| null

		function maybeResume() {
		if (resume) {
		resume()
		resume = null
		}
		}

		src
		.on('readable', maybeResume)
		.on('error', (err) => {
		error = err
		maybeResume()
		})
		.on('end', () => {
		ended = true
		maybeResume()
		})
		.on('close', maybeResume)

		const decoder = new TextDecoder('utf-8')
		let str = ''
		async function* _changes({ live, retry, params, method, body, signal, client, logger, highWaterMark = 128 * 1024, blocking = live \|\| !params.limit \|\| params.limit > 256, priority, }) {
		const startSeq = params.since \|\| null;
		// Fetched lazily inside the retry loop (undefined = not yet fetched,
		// null = fetched but absent) so a failing probe at feed start goes
		// through the same retry contract as the _changes request itself.
		let updateSeq;
		let retryCount = 0;
		let retryTime = 0;
		while (true) {
		const chunk = src.read()

		let text = null
		if (chunk != null) {
		text = decoder.decode(chunk, { stream: true })
		} else if (ended) {
		text = decoder.decode() \|\| null
		}

		if (text != null) {
		const lines = (str + text).split(/\r?\n/)

		str = lines.pop() ?? ''

		for (const line of lines) {
		if (line === '') {
		// Do nothing. Empty lines due to e.g. heartbeat.
		} else if (line === ',') {
		// Do nothing. Couch sometimes insert new line between json body and comma.
		} else if (live) {
		const data = JSON.parse(line)
		if (data.last_seq) {
		since = data.last_seq
		} else {
		since = data.seq \|\| since
		changes.push(data)
		let src;
		try {
		if (updateSeq === undefined) {
		// NOTE: Pass the URL as the first argument and the dispatcher in the
		// options object so nxt-undici uses the configured `client` instead
		// of the ambient global dispatcher (which may be Node's built-in
		// undici, whose handler interface is incompatible). retry: false so
		// error classification is owned by this loop's catch, like _changes.
		const info = (await undiciRequest(new URL(dbPathname, dbOrigin), {
		signal,
		dispatcher: client,
		retry: false,
		}).then((res) => res.body.json()));
		updateSeq = info.update_seq ?? null;
		}
		} else {
		// NOTE: This makes some assumptions about the format of the JSON.
		if (state === 0) {
		if (line.endsWith('[')) {
		state = 1
		} else {
		assert(false, 'invalid head: ' + line)
		}
		} else if (state === 1) {
		if (line.startsWith(']')) {
		state = 2
		} else {
		const idx = line.lastIndexOf('}') + 1
		const query = { ...params, feed: live ? 'continuous' : 'normal' };
		// NOTE: URL as the first argument, everything else (including the
		// dispatcher) in the options object — see the update_seq probe above.
		const ures = await undiciRequest(new URL(urlJoin(dbPathname, '/_changes'), dbOrigin), {
		query,
		headers: body
		? {
		'content-type': 'application/json',
		}
		: null,
		blocking,
		method,
		body: JSON.stringify(body),
		retry: false,
		idempotent: false,
		signal,
		headersTimeout: 2 * 60e3,
		bodyTimeout: 2 * (params.heartbeat \|\| 60e3),
		highWaterMark,
		dispatcher: client,
		logger,
		priority,
		});
		retryCount = 0;
		retryTime = 0;
		src = ures.body;
		const changes = [];
		let resume = null;
		let error = null;
		let ended = false;
		let state = 0;
		let since = params.since \|\| null;
		function maybeResume() {
		if (resume) {
		resume();
		resume = null;
		}
		}
		src
		.on('readable', maybeResume)
		.on('error', (err) => {
		error = err;
		maybeResume();
		})
		.on('end', () => {
		ended = true;
		maybeResume();
		})
		.on('close', maybeResume);
		const decoder = new TextDecoder('utf-8');
		let str = '';
		while (true) {
		const chunk = src.read();
		let text = null;
		if (chunk != null) {
		text = decoder.decode(chunk, { stream: true });
		}
		else if (ended) {
		text = decoder.decode() \|\| null;
		}
		if (text != null) {
		const lines = (str + text).split(/\r?\n/);
		str = lines.pop() ?? '';
		for (const line of lines) {
		if (line === '') {
		// Do nothing. Empty lines due to e.g. heartbeat.
		}
		else if (line === ',') {
		// Do nothing. Couch sometimes insert new line between json body and comma.
		}
		else if (live) {
		const data = JSON.parse(line);
		if (data.last_seq) {
		since = data.last_seq;
		}
		else {
		since = data.seq \|\| since;
		changes.push(data);
		}
		}
		else {
		// NOTE: This makes some assumptions about the format of the JSON.
		if (state === 0) {
		if (line.endsWith('[')) {
		state = 1;
		}
		else {
		assert(false, 'invalid head: ' + line);
		}
		}
		else if (state === 1) {
		if (line.startsWith(']')) {
		state = 2;
		}
		else {
		const idx = line.lastIndexOf('}') + 1;
		try {
		assert(idx > 0, 'invalid row: ' + idx + ' ' + line);
		const change = JSON.parse(line.slice(0, idx));
		since = change.seq \|\| since;
		changes.push(change);
		}
		catch (err) {
		throw Object.assign(err, { data: line });
		}
		}
		}
		else if (state === 2) {
		state = 3;
		since = JSON.parse('{' + line).last_seq;
		assert(since, 'invalid trailer: ' + line);
		}
		}
		}
		}
		else if (changes.length) {
		const ret = changes.splice(0);
		ret.lastSeq = params.since = since;
		yield ret;
		// Shrink the remaining cap so a reconnect only ever asks for the
		// remainder — re-sending the original limit after a mid-feed retry
		// would deliver more rows than the caller requested.
		if (params.limit != null) {
		params.limit -= ret.length;
		if (params.limit <= 0) {
		return;
		}
		}
		}
		else if (error) {
		// Cast: `error` is assigned from a stream callback, so the linter
		// cannot narrow Error \| null through the truthiness guard above.
		throw error;
		}
		else if (!ended) {
		await new Promise((resolve) => {
		resume = resolve;
		});
		}
		else {
		if (since === startSeq && params.limit == null) {
		since = params.until \|\| updateSeq \|\| null;
		}
		const ret = changes.splice(0);
		ret.lastSeq = params.since = since;
		yield ret;
		return;
		}
		}
		}
		catch (err) {
		// signal.aborted covers caller-provided abort reasons whose name is
		// not 'AbortError' — those must terminate the feed, not enter retry.
		if (signal.aborted \|\| err?.name === 'AbortError' \|\| !retry) {
		throw err;
		}
		else {
		logger?.error({ err }, 'changes error');
		retryTime \|\|= Date.now();
		const retryState = { since: params.since, time: retryTime, count: retryCount };
		try {
		assert(idx > 0, 'invalid row: ' + idx + ' ' + line)
		const change = JSON.parse(line.slice(0, idx))
		since = change.seq \|\| since
		changes.push(change)
		} catch (err) {
		throw Object.assign(err, { data: line })
		await retry(err, retryCount++, retryState, { signal, logger }, () => {
		const { statusCode, code, message, headers, res } = err;
		if (retryTime && Date.now() - retryTime > 2 * 60e3) {
		throw err;
		}
		if (statusCode != null && [420, 429, 502, 503, 504].includes(statusCode)) {
		// nxt-undici decorates response errors with the headers on
		// err.res.headers, not err.headers.
		const retryAfterRaw = headers?.['retry-after'] ?? res?.headers?.['retry-after'];
		const retryAfter = retryAfterRaw ? Number(retryAfterRaw) * 1e3 : null;
		// Clamp the server-controlled delay (same bound as nxt-undici's
		// response-retry): a hostile/huge value would overflow the
		// 32-bit timer and fire after ~1ms — a hot reconnect loop — and
		// even a valid large value must not exceed the 2-minute give-up.
		const delay = retryAfter != null && Number.isFinite(retryAfter)
		? Math.min(retryAfter, 60e3)
		: Math.min(10e3, retryCount * 1e3);
		return tp.setTimeout(delay, true, { signal });
		}
		if (code != null && CHANGES_RETRYABLE_ERROR_CODES.includes(code)) {
		return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, {
		signal,
		});
		}
		if (message != null && ['other side closed'].includes(message)) {
		return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, {
		signal,
		});
		}
		throw err;
		});
		}
		}
		} else if (state === 2) {
		state = 3
		since = JSON.parse('{' + line).last_seq
		assert(since, 'invalid trailer: ' + line)
		catch (retryErr) {
		// Aborting during the retry sleep rejects tp.setTimeout with a
		// generic AbortError; surface the caller's abort reason instead,
		// matching the in-flight abort path above.
		if (signal.aborted) {
		throw signal.reason ?? retryErr;
		}
		throw retryErr;
		}
		params.since = retryState.since ?? 0;
		}
		}
		}
		} else if (changes.length) {
		const ret = changes.splice(0)
		ret.lastSeq = params.since = since
		yield ret
		} else if (error) {
		throw error
		} else if (!ended) {
		await new Promise((resolve) => {
		resume = resolve
		})
		} else {
		if (since === startSeq && params.limit == null) {
		since = params.until \|\| updateSeq
		finally {
		src?.on('error', () => { }).destroy();
		}

		const ret = changes.splice(0)
		ret.lastSeq = params.since = since
		yield ret
		return
		}
		}
		} catch (err) {
		if (err.name === 'AbortError' \|\| !retry) {
		throw err
		} else {
		logger?.error({ err }, 'changes error')

		retryTime \|\|= Date.now()
		const retryState = { since: params.since, time: retryTime, count: retryCount }
		await retry(err, retryCount++, retryState, { signal, logger }, () => {
		const { statusCode, code, message, headers } = err

		if (retryTime && Date.now() - retryTime > 2 * 60e3) {
		throw err
		}
		const ACCEPT_HEADERS = ['Accept', 'application/json'];
		const ACCEPT_CONTENT_TYPE_HEADERS = [...ACCEPT_HEADERS, 'Content-Type', 'application/json'];
		function request(url, { params, client = defaultClient, idempotent, body, method, headers, signal, }) {
		let headerList;
		if (Array.isArray(headers)) {
		headerList = headers;
		}
		else if (headers) {
		headerList = [];
		for (const [key, val] of Object.entries(headers)) {
		headerList.push(key, val);
		}

		if (statusCode && [420, 429, 502, 503, 504].includes(statusCode)) {
		const retryAfter = headers?.['retry-after']
		? Number(headers['retry-after']) * 1e3
		: null
		const delay =
		retryAfter != null && Number.isFinite(retryAfter)
		? retryAfter
		: Math.min(10e3, retryCount * 1e3)
		return tp.setTimeout(delay, true, { signal })
		}

		if (
		[
		'ECONNRESET',
		'ECONNREFUSED',
		'ENOTFOUND',
		'ENETDOWN',
		'ENETUNREACH',
		'EHOSTDOWN',
		'EHOSTUNREACH',
		'EPIPE',
		'EAI_AGAIN',
		'ENODATA',
		'UND_ERR_CONNECT_TIMEOUT',
		'UND_ERR_SOCKET',
		].includes(code)
		) {
		return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, {
		}
		else {
		// Copy the shared default array: the user-agent append below mutates
		// `headerList` in place, which must not leak into the module-level constant.
		headerList = [...(body != null ? ACCEPT_CONTENT_TYPE_HEADERS : ACCEPT_HEADERS)];
		}
		if (userAgent &&
		!headerList.some((element, index) => index % 2 === 0 && /user-agent/i.test(element))) {
		headerList.push('user-agent', userAgent);
		}
		let path = dbPathname;
		if (url) {
		path = urlJoin(path, url
		.split('/')
		.map((part) => encodeURIComponent(part))
		.join('/'));
		}
		if (params) {
		path += `?${querystring.stringify(params)}`;
		}
		const req = {
		path,
		origin: dbOrigin,
		idempotent,
		method,
		body: body != null &&
		typeof body === 'object' &&
		!Buffer.isBuffer(body) &&
		!ArrayBuffer.isView(body) &&
		!(body instanceof ArrayBuffer) &&
		typeof body.pipe !== 'function'
		? JSON.stringify(body)
		: body,
		headers: headerList,
		};
		return new Promise((resolve, reject) => {
		const handler = {
		resolve,
		reject,
		signal,
		})
		}

		if (['other side closed'].includes(message)) {
		return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, {
		signal,
		})
		}

		throw err
		})
		params.since = retryState.since ?? 0
		status: null,
		headers: null,
		abort: null,
		data: '',
		decoder: new TextDecoder(),
		onConnect(abort) {
		const signal = this.signal;
		if (!signal) {
		return;
		}
		if (signal.aborted) {
		abort(signal.reason ?? new AbortError());
		return;
		}
		// Wrap the undici abort callback: registering it directly as an
		// EventTarget listener would invoke it with the 'abort' Event object,
		// which then propagates as the rejection "error".
		const onAbort = () => {
		abort(signal.reason ?? new AbortError());
		};
		this.abort = onAbort;
		addAbortListener(signal, onAbort);
		},
		onHeaders(statusCode, headers) {
		this.status = statusCode;
		this.headers = headers;
		},
		onData(chunk) {
		this.data += this.decoder.decode(chunk, { stream: true });
		},
		onComplete() {
		if (this.signal && this.abort) {
		removeAbortListener(this.signal, this.abort);
		}
		this.data += this.decoder.decode();
		const status = this.status ?? 0;
		const resHeaders = this.headers ?? {};
		// Match the media type only, ignoring any parameters such as
		// `charset` (e.g. `application/json; charset=utf-8`). The JSON.parse
		// below is not guarded, so we must not broaden this to subtypes like
		// `application/json-seq`.
		const rawContentType = resHeaders['content-type'];
		const contentType = (typeof rawContentType === 'string' ? rawContentType : '')
		.split(';', 1)[0]
		.trim()
		.toLowerCase();
		// Check the status before parsing. An error response can carry a
		// body that is not valid JSON despite an `application/json`
		// content-type (e.g. a truncated body or an HTML error page injected
		// by a reverse proxy on a 5xx). Parsing first would throw a raw
		// SyntaxError and the caller would never receive the intended HTTP
		// error (with `status`/`data`) that `makeError` builds from the raw
		// body.
		if (status < 200 \|\| status >= 300) {
		this.reject(makeError(req, {
		status,
		headers: resHeaders,
		data: this.data,
		}));
		return;
		}
		let data = this.data;
		if (contentType === 'application/json') {
		try {
		data = JSON.parse(this.data);
		}
		catch (err) {
		// Reject instead of throwing out of onComplete — nxt-undici
		// treats the dispatch as settled at this point, so an exception
		// here would leave the promise pending forever.
		this.reject(Object.assign(new Error('invalid json'), { data: this.data, cause: err }));
		return;
		}
		}
		this.resolve({
		data: data,
		status,
		headers: resHeaders,
		});
		},
		onError(err) {
		if (this.signal && this.abort) {
		removeAbortListener(this.signal, this.abort);
		}
		this.reject(err);
		},
		};
		void dispatch(client, req, handler);
		});
		}
		async function bulkDocs(body, opts = {}) {
		const { client = getClient('_bulk_docs'), signal, idempotent = true } = opts;
		const req = {
		pathname: '_bulk_docs',
		client,
		idempotent,
		body,
		method: 'POST',
		signal,
		};
		const res = await request(req.pathname, req);
		// 202 Accepted is a successful write on a degraded cluster (quorum not
		// met, but the docs were durably committed to the reachable nodes).
		if (res.status !== 201 && res.status !== 202) {
		throw makeError(req, res);
		}
		} finally {
		src?.on('error', () => {}).destroy()
		}
		return res.data;
		}
		}

		const ACCEPT_HEADERS = ['Accept', 'application/json']
		const ACCEPT_CONTENT_TYPE_HEADERS = [...ACCEPT_HEADERS, 'Content-Type', 'application/json']

		function request(
		url,
		{ params, client = defaultClient, idempotent, body, method, headers, signal },
		) {
		if (Array.isArray(headers)) {
		// Do nothing...
		} else if (headers) {
		const entries = Object.entries(headers)
		headers = []
		for (const [key, val] of entries) {
		headers.push(key, val)
		}
		} else {
		// Copy the shared default array: the user-agent append below mutates
		// `headers` in place, which must not leak into the module-level constant.
		headers = [...(body ? ACCEPT_CONTENT_TYPE_HEADERS : ACCEPT_HEADERS)]
		async function allDocs(pathname, opts = {}) {
		if (pathname && typeof pathname === 'object') {
		opts = pathname;
		pathname = null;
		}
		pathname = pathname \|\| '_all_docs';
		const { client = getClient(pathname), signal, idempotent = true, ...options } = opts;
		const { params, method, headers, body } = _normalizeAllDocsOptions(options);
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method,
		headers,
		signal,
		};
		const res = await request(req.pathname, req);
		if (res.status !== 200) {
		throw makeError(req, res);
		}
		return res.data;
		}

		if (
		userAgent &&
		!headers.some((element, index) => index % 2 === 0 && /user-agent/i.test(element))
		) {
		headers.push('user-agent', userAgent)
		async function put(pathname, params, body, { client = defaultClient, signal, idempotent = true, headers = null } = {}) {
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'PUT',
		headers,
		signal,
		};
		const res = await request(req.pathname, req);
		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res);
		}
		return res.data;
		}

		let path = dbPathname

		if (url) {
		path = urljoin(
		path,
		url
		.split('/')
		.map((part) => encodeURIComponent(part))
		.join('/'),
		)
		async function post(pathname, params, body, opts = {}) {
		const { client, signal, idempotent = true, headers } = opts;
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'POST',
		headers,
		signal,
		};
		const res = await request(req.pathname, req);
		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res);
		}
		return res.data;
		}

		if (params) {
		path += `?${querystring.stringify(params)}`
		async function get(pathname, params, body, { client = getClient('_all_docs'), signal, idempotent = true, headers = null, } = {}) {
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'GET',
		headers,
		signal,
		};
		const res = await request(req.pathname, req);
		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res);
		}
		return res.data;
		}

		const req = {
		path,
		origin: dbOrigin,
		idempotent,
		method,
		body: typeof body === 'object' && body ? JSON.stringify(body) : body,
		headers,
		async function _delete(pathname, params, body, { client = defaultClient, signal, idempotent = true, headers = null } = {}) {
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'DELETE',
		headers,
		signal,
		};
		const res = await request(req.pathname, req);
		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res);
		}
		return res.data;
		}

		return new Promise((resolve, reject) =>
		dispatch(client, req, {
		resolve,
		reject,
		signal,
		status: null,
		headers: null,
		abort: null,
		data: '',
		decoder: new TextDecoder(),
		onConnect(abort) {
		if (!this.signal) {
		return
		}

		if (this.signal.aborted) {
		abort()
		return
		}

		this.abort = abort
		if ('addEventListener' in this.signal) {
		this.signal.addEventListener('abort', abort)
		} else {
		this.signal.addListener('abort', abort)
		}
		},
		onHeaders(statusCode, headers) {
		this.status = statusCode
		this.headers = headers
		},
		onData(chunk) {
		this.data += this.decoder.decode(chunk, { stream: true })
		},
		onComplete() {
		if (this.signal) {
		if ('removeEventListener' in this.signal) {
		this.signal.removeEventListener('abort', this.abort)
		} else {
		this.signal.removeListener('abort', this.abort)
		async function info(params, body, { client = defaultClient, signal, idempotent = true, headers = null } = {}) {
		const req = {
		pathname: null,
		params,
		client,
		idempotent,
		body,
		method: 'GET',
		headers,
		signal,
		};
		const res = await request(req.pathname, req);
		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res);
		}
		return res.data;
		}
		async function up({ client = defaultClient, signal, } = {}) {
		const res = await undiciRequest(new URL('/_up', dbOrigin), {
		signal,
		dispatcher: client,
		});
		return await res.body.json();
		}
		async function upsert(pathname,
		// `any` doc so the concrete function satisfies the generic
		// CouchClient.upsert<Doc> signature (unknown is not assignable to Doc).
		// oxlint-disable-next-line typescript/no-explicit-any
		diffFun, { client = defaultClient, signal, } = {}) {
		while (true) {
		let doc;
		try {
		doc = (await get(pathname, null, null, { client, signal }));
		}
		}

		this.data += this.decoder.decode()

		// Match the media type only, ignoring any parameters such as
		// `charset` (e.g. `application/json; charset=utf-8`). The JSON.parse
		// below is not guarded, so we must not broaden this to subtypes like
		// `application/json-seq`.
		const contentType = (this.headers['content-type'] ?? '')
		.split(';', 1)[0]
		.trim()
		.toLowerCase()

		// Check the status before parsing. An error response can carry a
		// body that is not valid JSON despite an `application/json`
		// content-type (e.g. a truncated body or an HTML error page injected
		// by a reverse proxy on a 5xx). Parsing first would throw a raw
		// SyntaxError and the caller would never receive the intended HTTP
		// error (with `status`/`data`) that `makeError` builds from the raw
		// body.
		if (this.status < 200 \|\| this.status >= 300) {
		this.reject(
		makeError(req, {
		status: this.status,
		headers: this.headers,
		data: this.data,
		}),
		)
		return
		}

		let data = this.data
		if (contentType === 'application/json') {
		data = JSON.parse(this.data)
		}

		this.resolve({
		data,
		status: this.status,
		headers: this.headers,
		})
		},
		onError(err) {
		if (this.signal) {
		if ('removeEventListener' in this.signal) {
		this.signal.removeEventListener('abort', this.abort)
		} else {
		this.signal.removeListener('abort', this.abort)
		catch (err) {
		if (err.status !== 404) {
		throw err;
		}
		// Use the full pathname, not just the trailing segment — a design doc
		// upsert('_design/foo') must create _id '_design/foo', not 'foo'.
		doc = {
		_id: pathname,
		};
		}
		}

		this.reject(err)
		},
		}),
		)
		}

		async function bulkDocs(body, opts = {}) {
		const { client = getClient('_bulk_docs'), signal, idempotent = true } = opts
		const req = {
		pathname: '_bulk_docs',
		client,
		idempotent,
		body,
		method: 'POST',
		signal,
		const docId = doc._id;
		const docRev = doc._rev;
		const newDoc = diffFun(doc);
		if (!newDoc \|\| (!docRev && newDoc._deleted)) {
		return { updated: false, rev: docRev, id: docId, doc };
		}
		newDoc._id = docId;
		newDoc._rev = docRev;
		try {
		return {
		...(await put(pathname, null, newDoc, { client, signal })),
		doc: newDoc,
		updated: true,
		};
		}
		catch (err) {
		if (err.status !== 409) {
		throw err;
		}
		}
		}
		}
		const res = await request(req.pathname, req)

		if (res.status !== 201) {
		throw makeError(req, res)
		async function close() {
		await defaultClient.close();
		// TODO (fix): Close other clients.
		}

		return res.data
		}

		async function allDocs(pathname, opts = {}) {
		if (pathname && typeof pathname === 'object') {
		opts = pathname
		pathname = null
		// `satisfies` keeps the implementation compile-checked against the exported
		// interface (a plain cast would let the two drift apart silently).
		return Object.freeze({
		url: new URL(dbUrl),
		request,
		bulkDocs,
		allDocs,
		put,
		post,
		get,
		upsert,
		delete: _delete,
		info,
		changes,
		close,
		up,
		});
		}
		function _normalizeAllDocsOptions({ conflicts, update_seq, descending, include_docs, sorted, key, startkey, start_key, startkey_docid, endkey, end_key, endkey_docid, inclusive_end, limit, skip, stale, reduce, stable, update, keys, group, group_level, ...rest }) {
		if (Object.keys(rest).length > 0) {
		throw new Error('invalid options: ' + JSON.stringify(rest));
		}

		pathname = pathname \|\| '_all_docs'

		const { client = getClient(pathname), signal, idempotent = true, ...options } = opts

		const { params, method, headers, body } = _normalizeAllDocsOptions(options)

		const req = {
		pathname: pathname \|\| '_all_docs',
		params,
		client,
		idempotent,
		body,
		method,
		headers,
		signal,
		const params = {};
		const headers = {
		Accept: 'application/json',
		};
		let method = 'GET';
		let body;
		if (conflicts) {
		params.conflicts = true;
		}
		const res = await request(req.pathname, req)

		if (res.status !== 200) {
		throw makeError(req, res)
		if (update_seq) {
		params.update_seq = true;
		}

		return res.data
		}

		async function put(
		pathname,
		params,
		body,
		{ client = defaultClient, signal, idempotent = true, headers = null } = {},
		) {
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'PUT',
		headers,
		signal,
		if (descending) {
		params.descending = true;
		}
		const res = await request(req.pathname, req)

		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res)
		if (include_docs) {
		params.include_docs = true;
		}

		return res.data
		}

		async function post(pathname, params, body, opts = {}) {
		const { client, signal, idempotent = true, headers } = opts
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'POST',
		headers,
		signal,
		// sorted defaults to true server-side, so false is the only value that does
		// anything — it must not be dropped by a truthiness check.
		if (sorted != null) {
		params.sorted = !!sorted;
		}
		const res = await request(req.pathname, req)

		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res)
		if (key != null) {
		params.key = JSON.stringify(key);
		}

		return res.data
		}

		async function get(
		pathname,
		params,
		body,
		{ client = getClient('_all_docs'), signal, idempotent = true, headers = null } = {},
		) {
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'GET',
		headers,
		signal,
		if (startkey != null \|\| start_key != null) {
		params.startkey = JSON.stringify(startkey ?? start_key);
		}
		const res = await request(req.pathname, req)

		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res)
		// startkey_docid/endkey_docid are plain document-id strings in CouchDB, NOT
		// JSON values (unlike key/startkey/endkey). JSON.stringify would send a quoted
		// value (e.g. `%22mydoc%22`) that never matches a real _id.
		if (startkey_docid != null) {
		params.startkey_docid = startkey_docid;
		}

		return res.data
		}

		async function _delete(
		pathname,
		params,
		body,
		{ client = defaultClient, signal, idempotent = true, headers = null } = {},
		) {
		const req = {
		pathname,
		params,
		client,
		idempotent,
		body,
		method: 'DELETE',
		headers,
		signal,
		if (endkey != null \|\| end_key != null) {
		params.endkey = JSON.stringify(endkey ?? end_key);
		}
		const res = await request(req.pathname, req)

		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res)
		if (endkey_docid != null) {
		params.endkey_docid = endkey_docid;
		}

		return res.data
		}

		async function info(
		params,
		body,
		{ client = defaultClient, signal, idempotent = true, headers = null } = {},
		) {
		const req = {
		pathname: null,
		params,
		client,
		idempotent,
		body,
		method: 'GET',
		headers,
		signal,
		if (inclusive_end != null) {
		params.inclusive_end = !!inclusive_end;
		}
		const res = await request(req.pathname, req)

		if (res.status < 200 \|\| res.status >= 300) {
		throw makeError(req, res)
		if (limit != null) {
		params.limit = limit;
		}

		return res.data
		}

		async function up({ client = defaultClient, signal } = {}) {
		const res = await undiciRequest(new URL('/_up', dbOrigin), {
		signal,
		dispatcher: client,
		})
		return await res.body.json()
		}

		async function upsert(pathname, diffFun, { client = defaultClient, signal } = {}) {
		while (true) {
		let doc
		try {
		doc = await get(pathname, null, null, { client, signal })
		} catch (err) {
		if (err.status !== 404) {
		throw err
		}
		doc = {
		_id: pathname.split('/').pop(),
		}
		}

		const docId = doc._id
		const docRev = doc._rev

		const newDoc = diffFun(doc)

		if (!newDoc \|\| (!docRev && newDoc._deleted)) {
		return { updated: false, rev: docRev, id: docId, doc }
		}

		newDoc._id = docId
		newDoc._rev = docRev

		try {
		return {
		...(await put(pathname, null, newDoc, { client, signal })),
		doc: newDoc,
		updated: true,
		}
		} catch (err) {
		if (err.status !== 409) {
		throw err
		}
		}
		if (skip != null) {
		params.skip = skip;
		}
		}

		async function close() {
		await defaultClient.close()
		// TODO (fix): Close other clients.
		}

		return Object.freeze({
		url: new URL(config.url),
		request,
		bulkDocs,
		allDocs,
		put,
		post,
		get,
		upsert,
		delete: _delete,
		info,
		changes,
		close,
		up,
		})
		}

		function _normalizeAllDocsOptions({
		conflicts,
		update_seq,
		descending,
		include_docs,
		sorted,
		key,
		startkey,
		start_key,
		startkey_docid,
		endkey,
		end_key,
		endkey_docid,
		inclusive_end,
		limit,
		skip,
		stale,
		reduce,
		stable,
		update,
		keys,
		group,
		group_level,
		...rest
		}) {
		if (Object.keys(rest).length > 0) {
		throw new Error('invalid options: ' + JSON.stringify(rest))
		}
		const params = {}
		const headers = {
		Accept: 'application/json',
		}

		let method = 'GET'
		let body

		if (conflicts) {
		params.conflicts = true
		}

		if (update_seq) {
		params.update_seq = true
		}

		if (descending) {
		params.descending = true
		}

		if (include_docs) {
		params.include_docs = true
		}

		if (sorted) {
		params.sorted = true
		}

		if (key != null) {
		params.key = JSON.stringify(key)
		}

		if (startkey != null \|\| start_key != null) {
		params.startkey = JSON.stringify(startkey ?? start_key)
		}

		// startkey_docid/endkey_docid are plain document-id strings in CouchDB, NOT
		// JSON values (unlike key/startkey/endkey). JSON.stringify would send a quoted
		// value (e.g. `%22mydoc%22`) that never matches a real _id.
		if (startkey_docid != null) {
		params.startkey_docid = startkey_docid
		}

		if (endkey != null \|\| end_key != null) {
		params.endkey = JSON.stringify(endkey ?? end_key)
		}

		if (endkey_docid != null) {
		params.endkey_docid = endkey_docid
		}

		if (inclusive_end != null) {
		params.inclusive_end = !!inclusive_end
		}

		if (limit != null) {
		params.limit = limit
		}

		if (skip != null) {
		params.skip = skip
		}

		if (stale != null) {
		params.stale = stale
		}

		if (reduce != null) {
		params.reduce = reduce
		}

		if (group != null) {
		params.group = group
		}

		if (group_level != null) {
		params.group_level = group_level
		}

		if (update != null) {
		params.update = update
		}

		if (stable != null) {
		params.stable = stable
		}

		if (keys != null) {
		method = 'POST'
		body = JSON.stringify({ keys })
		headers['Content-Type'] = 'application/json'
		}

		return {
		method,
		params,
		headers,
		body,
		}
		}

		class StreamOutput extends stream.Readable {
		#str
		#resume
		#abort
		#state
		#decoder
		#headers

		constructor({ signal, highWaterMark = 256 }) {
		super({ objectMode: true, highWaterMark, signal })
		}

		get headers() {
		return this.#headers
		}

		_read() {
		this.#resume?.()
		}

		_destroy(err, callback) {
		this.#abort?.(err)
		callback(err)
		}

		onConnect(abort) {
		if (this.destroyed) {
		abort(this.errored)
		} else if (this.#state) {
		throw new Error('unusable')
		} else {
		this.#state = 0
		this.#str = ''
		this.#abort = abort
		this.#decoder = new TextDecoder()
		if (stale != null) {
		params.stale = stale;
		}
		}

		onHeaders(statusCode, headers, resume) {
		if (statusCode >= 300 \|\| statusCode < 200) {
		throw new Error('invalid status code: ' + statusCode)
		if (reduce != null) {
		params.reduce = reduce;
		}

		this.#headers = headers
		this.#resume = resume
		}

		onData(data) {
		const lines = this.#decoder.decode(data, { stream: true }).split(/\r?\n+/)
		lines[0] = this.#str + lines[0]
		this.#str = lines.pop() ?? ''

		try {
		let ret = true
		for (const line of lines) {
		if (!line) {
		continue
		}
		if (this.#state === 0) {
		if (/\[\s*$/.test(line)) {
		this.#state = 1
		} else {
		throw new Error('expected [ at end of line')
		}
		} else if (this.#state === 1) {
		if (/^\s*\]/.test(line)) {
		this.#state = 2
		} else {
		const row = JSON.parse(line.slice(0, line.lastIndexOf('}') + 1))
		if (!this.push(row)) {
		ret = false
		}
		}
		}
		}
		return ret
		} catch (err) {
		throw Object.assign(new Error('invalid data'), {
		data: lines.join('\n') + this.#str,
		cause: err,
		})
		if (group != null) {
		params.group = group;
		}
		}

		onComplete() {
		assert(this.#state === 2)
		this.push(null)
		}

		onError(err) {
		this.destroy(err)
		}
		}

		class PromiseOutput {
		#resolve
		#reject
		#str
		#decoder
		#signal
		#abort

		constructor({ resolve, reject, signal }) {
		this.#resolve = resolve
		this.#reject = reject
		this.#signal = signal
		}

		onConnect(abort) {
		this.#decoder = new TextDecoder()
		this.#str = ''

		if (this.#signal?.aborted) {
		abort()
		} else {
		this.#abort = abort
		this.#signal?.addEventListener('abort', this.#abort)
		if (group_level != null) {
		params.group_level = group_level;
		}
		}

		onHeaders(statusCode, rawHeaders, resume, statusText) {
		if (statusCode >= 300 \|\| statusCode < 200) {
		throw new Error('invalid status code: ' + statusCode)
		if (update != null) {
		params.update = update;
		}
		}

		onData(data) {
		this.#str += this.#decoder.decode(data, { stream: true })
		}

		onComplete() {
		this.#str += this.#decoder.decode(undefined, { stream: false })
		try {
		this.#onDone(null, JSON.parse(this.#str))
		} catch (err) {
		this.#onDone(Object.assign(new Error('invalid json'), { data: this.#str, cause: err }))
		if (stable != null) {
		params.stable = stable;
		}
		}

		onError(err) {
		this.#onDone(err)
		}

		#onDone(err, val) {
		if (err) {
		this.#reject(err)
		} else {
		this.#resolve(val)
		if (keys != null) {
		method = 'POST';
		body = JSON.stringify({ keys });
		headers['Content-Type'] = 'application/json';
		}

		if (this.#abort) {
		this.#signal?.removeEventListener('abort', this.#abort)
		}
		}
		return {
		method,
		params,
		headers,
		body,
		};
		}

		const defaultDispatcher = new Agent({
		// pipelining: 4,
		connections: 8 * 4,
		connectTimeout: 2e3,
		})
		const blockingDispatcher = new Agent({
		pipelining: 1,
		connections: 1024,
		connectTimeout: 2e3,
		})

		export function request(url, opts) {
		if (typeof url === 'string') {
		opts = { url: new URL(url), ...opts }
		} else if (url instanceof URL) {
		opts = { url, ...opts }
		} else if (typeof url.origin === 'string' && typeof (url.path ?? url.pathname) === 'string') {
		opts = opts ? { ...url, ...opts } : url
		}

		if (opts == null && typeof url === 'object' && url != null) {
		opts = url
		}

		url = opts.url

		if (typeof url === 'string') {
		url = new URL(url)
		}

		let origin = url.origin
		if (!origin) {
		const protocol = url.protocol ?? 'http:'
		const host = url.host ?? `${url.hostname}:${url.port ?? (protocol === 'https:' ? 443 : 80)}`
		origin = `${protocol}//${host}`
		}

		let path = url.path
		if (!path) {
		path = url.search ? `${url.pathname}${url.search}` : url.pathname
		}

		const ureq = {
		...opts,
		dns:
		opts.dns !== false && opts.dns !== null
		? {
		balance: 'hash',
		...opts.dns,
		}
		: opts.dns,
		origin,
		path,
		method: opts.method ?? (opts.body ? 'POST' : 'GET'),
		blocking: opts.blocking ?? Boolean(opts.stream),
		headers: {
		'content-type':
		opts.body != null && typeof opts.body === 'object' ? 'application/json' : 'text/plain',
		accept: 'application/json',
		...opts.headers,
		},
		cache: false,
		body:
		opts.body != null && typeof opts.body === 'object' ? JSON.stringify(opts.body) : opts.body,
		}

		const dispatcher = opts.dispatcher ?? (ureq.blocking ? blockingDispatcher : defaultDispatcher)
		const signal = opts.signal

		if (opts.stream) {
		const handler = new StreamOutput({ signal, highWaterMark: stream.highWaterMark })
		dispatch(dispatcher, ureq, handler)
		return handler
		} else {
		return new Promise((resolve, reject) => {
		const handler = new PromiseOutput({ resolve, reject, signal })
		dispatch(dispatcher, ureq, handler)
		})
		}
		}

		globalThis.__nxt_lib_couch = {
		request,
		defaultDispatcher,
		}
		//# sourceMappingURL=index.js.map

+16

-11

package.json

		{
		"name": "@nxtedition/couch",
		"version": "1.1.51",
		"version": "2.0.0",
		"type": "module",
		@@ -8,3 +8,7 @@ "main": "lib/index.js",
		"exports": {
		".": "./lib/index.js"
		".": {
		"types": "./lib/index.d.ts",
		"source": "./src/index.ts",
		"default": "./lib/index.js"
		}
		},
		@@ -16,9 +20,10 @@ "files": [
		"scripts": {
		"build": "rimraf lib && mkdir -p lib && cp src/index.js lib/index.js && cp src/index.d.ts lib/index.d.ts",
		"build": "rimraf lib && tsc -p tsconfig.build.json",
		"typecheck": "tsc --noEmit",
		"test": "node --test",
		"test:ci": "node --test"
		"test": "node --conditions=source --test",
		"test:types": "tsd",
		"test:ci": "node --conditions=source --test && tsd"
		},
		"dependencies": {
		"@nxtedition/error": "^1.1.39",
		"@nxtedition/error": "^1.1.40",
		"@nxtedition/nxt-undici": "^7.3.27",
		@@ -30,9 +35,9 @@ "@nxtedition/weak-cache": "^1.0.12",
		"devDependencies": {
		"@nxtedition/logger": "^2.1.34",
		"@nxtedition/scheduler": "^4.1.18",
		"@types/http-errors": "^2.0.5",
		"@types/node": "^25.9.4",
		"rimraf": "^6.1.3",
		"typescript": "^5.9.3",
		"undici": "^7.28.0"
		"tsd": "^0.33.0",
		"typescript": "^5.9.3"
		},
		"gitHead": "44032308de159c06fc694c901a12c35a8bd628ea"
		"gitHead": "67d19205b4876ee6dc1c6c75742dbd64361cf70d"
		}

@nxtedition/couch - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes