@andrew_l/mongo-pagination 0.3.22 → 0.4.0

package/dist/_chunks/QueryPaginator.d.mts

@@ -0,0 +1,198 @@
+import { Sort } from "mongodb";
+import internal, { Readable } from "node:stream";
+interface TokenOptions {
+  /**
+   * The schema version of the token.
+   */
+  schemaVersion: number;
+  /**
+   * The name of the model the token is related to.
+   */
+  modelName?: string;
+  /**
+   * The sorting direction used to building pagination query.
+   */
+  sortDirection?: Record<string, any>;
+  /**
+   * The values associated with sorting.
+   * Used in conjunction with `sortDirection` to building range query.
+   */
+  sortValues?: Record<string, any>;
+  /**
+   * The payload of the token. Contains additional data or metadata (can be `null`).
+   */
+  payload: Record<string, any> | null;
+}
+/**
+ * Represents a token with pagination and metadata information.
+ * This class holds the token data, including sorting details, and any payload.
+ */
+declare class Token {
+  /**
+   * The CRC of the model name, used for verify the model.
+   */
+  modelNameCRC: number;
+  /**
+   * The sorting direction used for pagination building pagination query.
+   */
+  sortDirection: Record<string, any>;
+  /**
+   * The sorting values associated with the pagination.
+   */
+  sortValues: Record<string, any>;
+  /**
+   * The payload of the token, which can contain any associated metadata or data (may be `null`).
+   */
+  payload: Record<string, any> | null;
+  constructor(options?: Partial<TokenOptions>);
+  /**
+   * Retrieves the string representation of token.
+   */
+  stringify(): string;
+  /**
+   * Retrieves binary buffer representation of token.
+   */
+  buffer(): Uint8Array;
+  /**
+   * Encode token from provided value
+   */
+  static from(value: string | Buffer | Uint8Array): Token;
+}
+/**
+ * Parses a token from provided value.
+ * @group Utils
+ */
+declare function parseToken(value: string | Buffer): Token;
+/**
+ * Create a token with pagination and metadata information.
+ * This holds the token data, including sorting details, and any payload.
+ *
+ * @group Utils
+ */
+declare function createToken(options?: Partial<TokenOptions>): Token;
+declare namespace QueryAdapter {
+  type Options = {
+    sort?: Sort;
+    limit?: number;
+  };
+  type Filter = Record<string, any>;
+  interface QueryAdapter<T = any> {
+    getModelName(): string;
+    getOptions(): Options;
+    getFilter(): Filter;
+    setOptions(options: Options): void;
+    setFilter(filter: Filter): void;
+    toArray(): Promise<T[]>;
+    stream(): Readable;
+  }
+}
+interface QueryPaginatorOptions {
+  /**
+   * An optional list of fields used for building pagination query.
+   */
+  paginationFields?: string[];
+  /**
+   * The token to start the pagination from, if available.
+   */
+  next?: string | Buffer | null;
+  /**
+   * A callback function executed before the query is performed.
+   */
+  preQuery?: (this: QueryPaginator) => void;
+  /**
+   * A callback function executed after the query is performed.
+   */
+  postQuery?: (this: QueryPaginator) => void;
+  /** @internal */
+  debugQuery?: boolean;
+}
+interface QueryPaginatorMeta {
+  /**
+   * Indicates whether there is a next page available.
+   */
+  hasNext: boolean;
+  /**
+   * The token for the next page, or `null` if there is no next page.
+   */
+  next: string | null;
+}
+interface QueryPaginatorResult<T> {
+  /**
+   * The list of items for the current page.
+   */
+  items: T[];
+  /**
+   * Metadata providing information about pagination, such as whether more pages are available.
+   */
+  metadata: QueryPaginatorMeta;
+}
+/**
+ * A generic class for handling query pagination.
+ *
+ * Look at `withMongoPagination` and `withMongoosePagination`
+ *
+ * @group Main
+ */
+declare class QueryPaginator<T = any> {
+  private query;
+  private hooks;
+  private next;
+  private previous?;
+  private resHasNext;
+  private resLastItem;
+  private paginationFields;
+  private tweaked;
+  private debugQuery;
+  getMetadata: () => QueryPaginatorMeta;
+  constructor(query: QueryAdapter.QueryAdapter, {
+    paginationFields,
+    postQuery,
+    preQuery,
+    next: previousToken,
+    debugQuery
+  }?: QueryPaginatorOptions);
+  /**
+   * Retrieves metadata about the current state of pagination.
+   */
+  get metadata(): QueryPaginatorMeta;
+  /**
+   * Indicates whether there is a next page available.
+   */
+  get hasNext(): boolean;
+  /**
+   * Retrieves the token for the next page.
+   */
+  get nextToken(): Token;
+  /**
+   * Retrieves the string representation of the next page token.
+   * If there is no next page, returns `null`.
+   */
+  get nextTokenString(): string | null;
+  /**
+   * Retrieves the token for the previous page.
+   */
+  get prevToken(): Token | null;
+  /**
+   * Retrieves the string representation of the previous page token.
+   */
+  get prevTokenString(): string | null;
+  getQuery(): QueryAdapter.QueryAdapter<any>;
+  pre(hookName: string, fn: Function): this;
+  post(hookName: string, fn: Function): this;
+  stream(): Promise<internal.Transform>;
+  /** @internal */
+  maybeTweak(): this;
+  /** @internal */
+  tweak(): this;
+  /** @internal */
+  _handleResult(items: any[]): QueryPaginatorResult<any>;
+  /**
+   * Executes the query and returns the results along with pagination metadata.
+   */
+  exec(): Promise<QueryPaginatorResult<T>>;
+  then: Promise<QueryPaginatorResult<T>>["then"];
+  cath: Promise<QueryPaginatorResult<T>>["catch"];
+  finally: Promise<QueryPaginatorResult<T>>["finally"];
+}
+export { QueryAdapter, QueryPaginator, QueryPaginatorMeta, QueryPaginatorOptions, QueryPaginatorResult, Token, TokenOptions, createToken, parseToken };
+//# sourceMappingURL=QueryPaginator.d.mts.map

package/dist/_chunks/QueryPaginator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryPaginator.d.mts","names":["schemaVersion","modelName","sortDirection","Record","sortValues","payload","modelNameCRC","constructor","Partial","TokenOptions","options","stringify","buffer","Uint8Array","from","Buffer","value","Token","Options","sort","Sort","limit","Filter","Record","QueryAdapter","T","getModelName","getOptions","getFilter","setOptions","options","setFilter","filter","toArray","Promise","stream","Readable","paginationFields","next","Buffer","preQuery","QueryPaginator","this","postQuery","debugQuery","hasNext","T","items","metadata","QueryPaginatorMeta","query","hooks","previous","resHasNext","resLastItem","tweaked","getMetadata","constructor","QueryAdapter","previousToken","QueryPaginatorOptions","nextToken","Token","nextTokenString","prevToken","prevTokenString","getQuery","pre","hookName","Function","fn","post","stream","Promise","internal","Transform","maybeTweak","tweak","_handleResult","QueryPaginatorResult","exec","then","cath","finally"],"sources":["../../src/Token.d.ts","../../src/QueryAdapter.d.ts","../../src/QueryPaginator.d.ts"],"mappings":";;UAAiB,YAAA;;;AAAjB;EAIIA,aAAAA;;;;EAIAC,SAAAA;EAae;;;EATfC,aAAAA,GAAgB,MAAA;EAAhBA;;;;EAKAE,UAAAA,GAAa,MAAA;EAIJD;;AAAM;EAAfE,OAAAA,EAAS,MAAA;AAAA;;;;;cAMQ,KAAA;EAiBK;;;EAbtBC,YAAAA;EAyBkD;;;EArBlDJ,aAAAA,EAAe,MAAA;EAAfA;;;EAIAE,UAAAA,EAAY,MAAA;EAIZC;;;EAAAA,OAAAA,EAAS,MAAA;EACTE,WAAAA,CAAYG,OAAAA,GAAU,OAAA,CAAQ,YAAA;EAAlBA;;;EAIZC,SAAAA;EAQOG;;;EAJPF,MAAAA,IAAU,UAAA;EAIwCK;;AAAK;EAALA,OAA3CH,IAAAA,CAAKE,KAAAA,WAAgB,MAAA,GAAS,UAAA,GAAa,KAAA;AAAA;;;;;iBAM9B,UAAA,CAAWA,KAAAA,WAAgB,MAAA,GAAS,KAAK;;AAAA;AAOjE;;;;iBAAwB,WAAA,CAAYN,OAAAA,GAAU,OAAA,CAAQ,YAAA,IAAgB,KAAA;AAAA,kBCnE7C,YAAA;EAAA,KAChBQ,OAAAA;IACDC,IAAAA,GAAO,IAAA;IACPE,KAAAA;EAAAA;EAAAA,KAECC,MAAAA,GAAS,MAAA;EAAA,UACJE,YAAAA;IACNE,YAAAA;IACAC,UAAAA,IAAc,OAAA;IACdC,SAAAA,IAAa,MAAA;IACbC,UAAAA,CAAWC,OAAAA,EAAS,OAAA;IACpBC,SAAAA,CAAUC,MAAAA,EAAQ,MAAA;IAClBC,OAAAA,IAAW,OAAA,CAAQ,CAAA;IACnBE,MAAAA,IAAU,QAAA;EAAA;AAAA;AAAA,UCZD,qBAAA;EFHY;;;EEOzBE,gBAAAA;EFcS;;;EEVTC,IAAAA,YAAgB,MAAA;EFHhBrC;;;EEOAuC,QAAAA,IAAYE,IAAAA,EAAM,cAAA;EFELvC;;;EEEbwC,SAAAA,IAAaD,IAAAA,EAAM,cAAA;EFEJ;EEAfE,UAAAA;AAAAA;AAAAA,UAEa,kBAAA;EFYE;;;EERfC,OAAAA;EFiBsB;;;EEbtBP,IAAI;AAAA;AAAA,UAES,oBAAA;EFuB0C;;;EEnBvDS,KAAAA,EAAO,CAAA;EFEP3C;;;EEEA4C,QAAAA,EAAU,kBAAkB;AAAA;;;;;;;;cASX,cAAA;EAAA,QACTE,KAAAA;EAAAA,QACAC,KAAAA;EAAAA,QACAb,IAAAA;EAAAA,QACAc,QAAAA;EAAAA,QACAC,UAAAA;EAAAA,QACAC,WAAAA;EAAAA,QACAjB,gBAAAA;EAAAA,QACAkB,OAAAA;EAAAA,QACAX,UAAAA;EACRY,WAAAA,QAAmB,kBAAA;EACnBC,WAAAA,CAAYP,KAAAA,EAAO,YAAA,CAAa,YAAA;IAAgBb,gBAAAA;IAAkBM,SAAAA;IAAWH,QAAAA;IAAUF,IAAAA,EAAM,aAAA;IAAeM;EAAAA,IAAgB,qBAAA;EFCpE3B;;AAAK;EAALA,IEGpD+B,QAAAA,IAAY,kBAAA;EFIe;;;EAAA,IEA3BH,OAAAA;EFA8D;;;EAAA,IEI9DgB,SAAAA,IAAa,KAAA;EFJiCpD;;;;EAAAA,IES9CsD,eAAAA;;AD5ER;;MCgFQC,SAAAA,IAAa,KAAA;ED9EN;;;EAAA,ICkFPC,eAAAA;EACJC,QAAAA,IAAY,YAAA,CAAa,YAAA;EACzBC,GAAAA,CAAIC,QAAAA,UAAkBE,EAAAA,EAAI,QAAA;EAC1BC,IAAAA,CAAKH,QAAAA,UAAkBE,EAAAA,EAAI,QAAA;EAC3BE,MAAAA,IAAU,OAAA,CAAQ,QAAA,CAAS,SAAA;ED3Eb;EC6EdI,UAAAA;ED7EsB;EC+EtBC,KAAAA;ED1FI1D;EC4FJ2D,aAAAA,CAAc/B,KAAAA,UAAe,oBAAA;ED3FzB1B;;;EC+FJ2D,IAAAA,IAAQ,OAAA,CAAQ,oBAAA,CAAqB,CAAA;EACrCC,IAAAA,EAAM,OAAA,CAAQ,oBAAA,CAAqB,CAAA;EACnCC,IAAAA,EAAM,OAAA,CAAQ,oBAAA,CAAqB,CAAA;EACnCC,OAAAA,EAAS,OAAA,CAAQ,oBAAA,CAAqB,CAAA;AAAA"}

package/dist/_chunks/withMongoosePagination.mjs

@@ -0,0 +1,489 @@
+import { CORE_TYPES, createExtension, defineStructure } from "@andrew_l/tl-pack";
+import { base62Fast, cleanEmpty, crc32, deepClone, intersection, isEmpty, isFunction, isNumber, isObject, pick, toError } from "@andrew_l/toolkit";
+import { MongoInvalidArgumentError, ObjectId } from "mongodb";
+import d from "debug";
+import Kareem from "kareem";
+import { Transform } from "node:stream";
+const extensions = [createExtension(100, {
+	encode(value) {
+		if (value?._bsontype?.toLowerCase() === "objectid") this.writeBytes(value.id);
+	},
+	decode() {
+		return new ObjectId(this.readBytes());
+	}
+})];
+const TokenStructure = defineStructure({
+	name: "PaginationToken",
+	version: 1,
+	checksum: true,
+	properties: {
+		modelNameCrc: {
+			type: CORE_TYPES.Int32,
+			required: true
+		},
+		keys: {
+			type: [String],
+			required: true
+		},
+		sortDirection: {
+			type: [null],
+			required: true
+		},
+		sortValues: {
+			type: [null],
+			required: true
+		},
+		payload: { type: Object }
+	}
+});
+var Token = class Token {
+	modelNameCRC = 0;
+	sortDirection = {};
+	sortValues = {};
+	payload = null;
+	constructor(options) {
+		if (options) {
+			Object.assign(this, {
+				...options,
+				modelName: void 0
+			});
+			if (options.modelName) this.modelNameCRC = crc32(options.modelName);
+		}
+	}
+	stringify() {
+		return base62Fast.encode(this.buffer());
+	}
+	buffer() {
+		return new TokenStructure({
+			modelNameCrc: this.modelNameCRC,
+			sortDirection: Object.values(this.sortDirection),
+			sortValues: Object.values(this.sortValues),
+			keys: Object.keys(this.sortValues),
+			payload: this.payload
+		}).toBuffer({ extensions });
+	}
+	static from(value) {
+		const buffer = Buffer.isBuffer(value) || value instanceof Uint8Array ? value : base62Fast.decode(value);
+		const struct = TokenStructure.fromBuffer(buffer, { extensions });
+		const token = new Token();
+		token.modelNameCRC = struct.modelNameCrc;
+		token.sortDirection = {};
+		token.sortValues = {};
+		token.payload = struct.payload ?? {};
+		for (let idx = 0; idx < struct.keys.length; idx++) {
+			token.sortValues[struct.keys[idx]] = struct.sortValues[idx];
+			token.sortDirection[struct.keys[idx]] = struct.sortDirection[idx];
+		}
+		return token;
+	}
+};
+function parseToken(value) {
+	return Token.from(value);
+}
+function createToken(options) {
+	return new Token(options);
+}
+const debug = {
+	init: d("mongo-pagination:init"),
+	tweak: d("mongo-pagination:tweak"),
+	exec: d("mongo-pagination:exec"),
+	stream: d("mongo-pagination:query:stream")
+};
+function isEmptyObject(obj) {
+	return !isObject(obj) || isEmpty(obj);
+}
+function sameKeys(...args) {
+	return intersection(...args.map((v) => Object.keys(v)));
+}
+function defineGetter(obj, key, getterFn) {
+	delete obj[key];
+	Object.defineProperty(obj, key, {
+		get: getterFn,
+		enumerable: true,
+		configurable: true
+	});
+}
+function isLastKeys(value, keys, strictOrder) {
+	const lastKeys = (isObject(value) ? Object.keys(value) : []).slice(-keys.length);
+	if (lastKeys.length !== keys.length) return false;
+	for (let idx = 0; idx < keys.length; idx++) if (strictOrder) {
+		if (lastKeys[idx] !== keys[idx]) return false;
+	} else if (!lastKeys.includes(keys[idx])) return false;
+	return true;
+}
+function toObject(value) {
+	return isFunction(value?.toObject) ? value?.toObject() : value;
+}
+function prepareDirection(direction = 1) {
+	const value = `${direction}`.toLowerCase();
+	if (isMeta(direction)) return direction;
+	switch (value) {
+		case "ascending":
+		case "asc":
+		case "1": return 1;
+		case "descending":
+		case "desc":
+		case "-1": return -1;
+		default: throw new MongoInvalidArgumentError(`Invalid sort direction: ${JSON.stringify(direction)}`);
+	}
+}
+function isMeta(t) {
+	return typeof t === "object" && t != null && "$meta" in t && typeof t.$meta === "string";
+}
+function isPair(t) {
+	if (Array.isArray(t) && t.length === 2) try {
+		prepareDirection(t[1]);
+		return true;
+	} catch {
+		return false;
+	}
+	return false;
+}
+function isDeep(t) {
+	return Array.isArray(t) && Array.isArray(t[0]);
+}
+function isMap(t) {
+	return t instanceof Map && t.size > 0;
+}
+function pairToMap(v) {
+	return /* @__PURE__ */ new Map([[`${v[0]}`, prepareDirection([v[1]])]]);
+}
+function deepToMap(t) {
+	const sortEntries = t.map(([k, v]) => [`${k}`, prepareDirection(v)]);
+	return new Map(sortEntries);
+}
+function stringsToMap(t) {
+	const sortEntries = t.map((key) => [`${key}`, 1]);
+	return new Map(sortEntries);
+}
+function objectToMap(t) {
+	const sortEntries = Object.entries(t).map(([k, v]) => [`${k}`, prepareDirection(v)]);
+	return new Map(sortEntries);
+}
+function mapToMap(t) {
+	const sortEntries = Array.from(t).map(([k, v]) => [`${k}`, prepareDirection(v)]);
+	return new Map(sortEntries);
+}
+function formatSort(sort, direction) {
+	if (sort == null) return void 0;
+	if (typeof sort === "string") return /* @__PURE__ */ new Map([[sort, prepareDirection(direction)]]);
+	if (typeof sort !== "object") throw new MongoInvalidArgumentError(`Invalid sort format: ${JSON.stringify(sort)} Sort must be a valid object`);
+	if (!Array.isArray(sort)) return isMap(sort) ? mapToMap(sort) : Object.keys(sort).length ? objectToMap(sort) : void 0;
+	if (!sort.length) return void 0;
+	if (isDeep(sort)) return deepToMap(sort);
+	if (isPair(sort)) return pairToMap(sort);
+	return stringsToMap(sort);
+}
+const DEF_LIMIT = 10;
+function createRangeFilter(sortDirection, sortValues) {
+	const sortCmd = formatSort(sortDirection) ?? {};
+	const keys = [];
+	for (const [sortKey, sortValue] of sortCmd.entries()) {
+		if (sortValues[sortKey] === void 0) continue;
+		if (!isNumber(sortValue)) continue;
+		keys.push(sortKey);
+	}
+	const op = (sortKey) => {
+		return sortCmd.get(sortKey) === 1 ? "$gt" : "$lt";
+	};
+	const val = (sortKey) => sortValues[sortKey];
+	if (keys.length === 0) return {};
+	else if (keys.length === 1) {
+		const sortKey = keys[0];
+		return { [sortKey]: { [op(sortKey)]: val(sortKey) } };
+	}
+	const $or = [];
+	const keysAmount = keys.length;
+	for (let i = 0; i < keysAmount; i++) {
+		const sortKey = keys[i];
+		if (i === 0) $or.push({ [sortKey]: { [op(sortKey)]: val(sortKey) } });
+		else {
+			const filter = {};
+			keys.slice(0, i).map((sortKey) => {
+				filter[sortKey] = { $eq: val(sortKey) };
+			});
+			const sortKey = keys[i];
+			filter[sortKey] = { [op(sortKey)]: val(sortKey) };
+			$or.push(filter);
+		}
+	}
+	if ($or.length === 1) return $or[0];
+	return { $or };
+}
+function mergeFilters(first, second) {
+	switch (true) {
+		case isEmptyObject(first): return deepClone(second);
+		case isEmptyObject(second): return deepClone(first);
+		case sameKeys(first, second).length === 0: return Object.assign(deepClone(first), deepClone(second));
+		case Array.isArray(first.$and):
+			first = deepClone(first);
+			second = deepClone(second);
+			if (Object.keys(second).length === 1 && second.$and) first.$and.push(...second.$and);
+			else first.$and.push(second);
+			return first;
+		default: return { $and: [deepClone(first), deepClone(second)] };
+	}
+}
+function tweakQuery({ paginationFields, token, query }) {
+	let queryOptions = deepClone(query.getOptions());
+	let queryFilter = deepClone(query.getFilter());
+	paginationFields = deepClone(paginationFields);
+	if (queryOptions.sort) {
+		const sortMap = formatSort(queryOptions.sort);
+		if (sortMap) queryOptions.sort = Object.fromEntries(sortMap.entries());
+	}
+	if (token) {
+		if (!isEmptyObject(token.sortDirection)) {
+			debug.tweak("set from token [queryOptions.sort] = %o", token.sortDirection);
+			queryOptions.sort = token.sortDirection;
+		}
+		if (!isEmptyObject(token.sortValues)) {
+			const rangeFilter = createRangeFilter(queryOptions.sort, token.sortValues);
+			debug.tweak("range conditions:\n	sortDirection = %o\n	sortValues = %o\n	result = %o", queryOptions.sort, token.sortValues, rangeFilter);
+			queryFilter = mergeFilters(queryFilter, rangeFilter);
+		}
+	}
+	if (isEmptyObject(queryOptions.sort)) {
+		queryOptions.sort = { _id: -1 };
+		debug.tweak("set default [queryOptions.sort] = %o", queryOptions.sort);
+	}
+	if (!Array.isArray(paginationFields) || !paginationFields.length) {
+		paginationFields = Object.keys(queryOptions.sort);
+		debug.tweak("set default [paginationFields] = %o", paginationFields);
+	}
+	if (!isLastKeys(queryOptions.sort, paginationFields)) throw new MongoInvalidArgumentError(`The query sort keys must ends with "${paginationFields.join(", ")}".`);
+	if (!queryOptions.limit) {
+		queryOptions.limit = 11;
+		debug.tweak("set default [queryOptions.limit] = %d", queryOptions.limit);
+	} else queryOptions.limit = Math.max(queryOptions.limit || DEF_LIMIT, 1) + 1;
+	query.setOptions(queryOptions);
+	query.setFilter(queryFilter);
+	return paginationFields;
+}
+var QueryAdapterMongoose = class {
+	query;
+	constructor(query) {
+		this.query = query;
+	}
+	getModelName() {
+		return this.query.model.modelName;
+	}
+	getOptions() {
+		const options = this.query.getOptions();
+		return {
+			limit: options.limit,
+			sort: options.sort
+		};
+	}
+	getFilter() {
+		return this.query.getFilter();
+	}
+	setOptions({ limit, sort }) {
+		this.query.setOptions(cleanEmpty({
+			limit,
+			sort
+		}));
+	}
+	setFilter(filter) {
+		this.query.setQuery(filter);
+	}
+	toArray() {
+		return this.query.exec();
+	}
+	stream() {
+		return this.query.cursor();
+	}
+};
+var Filter = class extends Transform {
+	has;
+	_count = 0;
+	constructor(has, options) {
+		super({
+			autoDestroy: true,
+			objectMode: true,
+			...options,
+			readableObjectMode: true,
+			writableObjectMode: true,
+			highWaterMark: 16
+		});
+		this.has = has;
+		this._count = -1;
+	}
+	_transform(chunk, encoding, next) {
+		const result = this.has(chunk, ++this._count);
+		if (typeof result === "boolean") if (result) return next(null, chunk);
+		else return next();
+		if ("then" in result) {
+			result.then((r) => {
+				if (r) next(null, chunk);
+			}).catch(next);
+			return;
+		}
+		next();
+	}
+};
+function streamFilter(fn, options) {
+	return new Filter(fn, options);
+}
+var QueryPaginator = class {
+	query;
+	hooks = new Kareem();
+	next;
+	previous;
+	resHasNext = false;
+	resLastItem = null;
+	paginationFields;
+	tweaked = false;
+	debugQuery = false;
+	getMetadata = () => this.metadata;
+	constructor(query, { paginationFields = [], postQuery, preQuery, next: previousToken, debugQuery = false } = {}) {
+		this.query = query;
+		this.paginationFields = paginationFields;
+		this.debugQuery = debugQuery;
+		this.next = createToken({
+			modelName: query.getModelName(),
+			sortDirection: {},
+			sortValues: {},
+			payload: {}
+		});
+		if (previousToken) {
+			try {
+				this.previous = Token.from(previousToken);
+				this.paginationFields = Object.keys(this.previous.sortValues);
+				debug.init("parse previous = %o", this.previous);
+				debug.init("set from previous [paginationFields] = %o", this.paginationFields);
+			} catch (orignErr) {
+				throw new MongoInvalidArgumentError("Failed to parse next pagination cursor.", { cause: toError(orignErr) });
+			}
+			const modelNameCRC = crc32(query.getModelName());
+			debug.init("compare model name: previous = %d, query = %d", this.previous.modelNameCRC, modelNameCRC);
+			if (modelNameCRC !== this.previous.modelNameCRC) throw new MongoInvalidArgumentError("The model name of next cursor token is not equal with query model name. Expected: " + this.query.getModelName());
+		}
+		if (preQuery) this.pre("query", preQuery);
+		if (postQuery) this.post("query", postQuery);
+		defineGetter(this.next, "sortDirection", () => {
+			const sortMap = formatSort(this.query.getOptions().sort);
+			return sortMap ? Object.fromEntries(sortMap.entries()) : {};
+		});
+		defineGetter(this.next, "sortValues", () => {
+			if (!this.resLastItem) return {};
+			return pick(this.resLastItem, this.paginationFields);
+		});
+		debug.init("with options = %o", arguments[1]);
+	}
+	get metadata() {
+		return {
+			hasNext: this.hasNext,
+			next: this.nextTokenString
+		};
+	}
+	get hasNext() {
+		return this.resHasNext;
+	}
+	get nextToken() {
+		return this.next;
+	}
+	get nextTokenString() {
+		if (!this.resHasNext) return null;
+		return this.next.stringify();
+	}
+	get prevToken() {
+		return this.previous || null;
+	}
+	get prevTokenString() {
+		return this.previous ? this.previous.stringify() : null;
+	}
+	getQuery() {
+		return this.query;
+	}
+	pre(hookName, fn) {
+		this.hooks.pre(hookName, fn);
+		return this;
+	}
+	post(hookName, fn) {
+		this.hooks.post(hookName, fn);
+		return this;
+	}
+	stream() {
+		return new Promise((resolve, reject) => {
+			this.hooks.execPre("query", this, [], (error) => {
+				if (error) return reject(error);
+				try {
+					this.maybeTweak();
+				} catch (err) {
+					return reject(err);
+				}
+				const limit = this.query.getOptions().limit;
+				const filter = streamFilter((item, index) => {
+					if (index + 1 === limit) {
+						this.resHasNext = true;
+						debug.stream("has next:\n	cutoff_idx = %d\n	next = %j", index, this.next);
+						return false;
+					} else this.resLastItem = toObject(item);
+					return true;
+				});
+				resolve(this.query.stream().pipe(filter));
+			});
+		});
+	}
+	maybeTweak() {
+		if (!this.tweaked) this.tweak();
+		return this;
+	}
+	tweak() {
+		this.paginationFields = tweakQuery({
+			query: this.query,
+			paginationFields: this.paginationFields,
+			token: this.previous
+		});
+		this.tweaked = true;
+		return this;
+	}
+	_handleResult(items) {
+		const limit = this.query.getOptions().limit;
+		if (items.length === limit) {
+			items.pop();
+			this.resHasNext = true;
+		}
+		this.resLastItem = toObject(items.at(-1));
+		if (this.resHasNext) debug.exec("has next:\n	cutoff_idx = %d\n	next = %j", limit - 1, this.next);
+		return {
+			metadata: this.getMetadata(),
+			items
+		};
+	}
+	exec() {
+		return new Promise((resolve, reject) => {
+			this.hooks.execPre("query", this, [], (preHookErr) => {
+				if (preHookErr) return reject(preHookErr);
+				if (this.debugQuery) console.info("pre tweak", {
+					queryFilter: this.query.getFilter(),
+					getOptions: this.query.getOptions(),
+					prevToken: this.prevToken
+				});
+				this.maybeTweak();
+				if (this.debugQuery) console.info("post tweak", {
+					queryFilter: this.query.getFilter(),
+					getOptions: this.query.getOptions(),
+					prevToken: this.prevToken
+				});
+				this.query.toArray().then((items) => {
+					const result = this._handleResult(items);
+					this.hooks.execPost("query", this, [], (postHookErr) => {
+						if (postHookErr) return reject(postHookErr);
+						return resolve(result);
+					});
+				}).catch(reject);
+			});
+		});
+	}
+	then = ((onfulfilled, onrejected) => this.exec().then(onfulfilled, onrejected));
+	cath = ((onrejected) => this.exec().catch(onrejected));
+	finally = ((onfinally) => this.exec().finally(onfinally));
+};
+function withMongoosePagination(query, options) {
+	return new QueryPaginator(new QueryAdapterMongoose(query), options);
+}
+export { QueryPaginator, createRangeFilter, createToken, mergeFilters, parseToken, tweakQuery, withMongoosePagination };
+
+//# sourceMappingURL=withMongoosePagination.mjs.map