@rebasepro/common 0.23.0 → 0.24.1-canary.g56af4a4

package/dist/data/cursor.es.js

@@ -0,0 +1,166 @@
+import { parseRelationAggregateSort } from "@rebasepro/types";
+//#region src/data/cursor.ts
+/** A cursor that cannot be read at all — truncated, re-encoded, or invented. */
+var CursorError = class CursorError extends Error {
+	code = "INVALID_CURSOR";
+	constructor(detail) {
+		super(`Invalid \`after\` cursor: ${detail}. Pass back the \`meta.nextCursor\` from the previous page unchanged — it is opaque and must not be built by hand.`);
+		this.name = "CursorError";
+		Object.setPrototypeOf(this, CursorError.prototype);
+	}
+};
+/**
+* A cursor that reads fine but describes a different query.
+*
+* Separate from {@link CursorError} because the fix is different: this one is
+* not a corrupt string, it is a correct cursor used against a sort it was not
+* produced under. Seeking anyway would return rows in an order nobody asked
+* for, and — worse — would look like it worked.
+*/
+var CursorMismatchError = class CursorMismatchError extends Error {
+	code = "CURSOR_ORDER_MISMATCH";
+	constructor(cursorKeys, queryKeys) {
+		super(`The \`after\` cursor was produced by a query ordered by ${cursorKeys.map((k) => `"${k}"`).join(", ") || "(nothing)"}, but this query orders by ${queryKeys.map((k) => `"${k}"`).join(", ") || "(nothing)"}. A cursor only continues the listing it came from — keep \`orderBy\` identical across pages, or drop \`after\` to start over.`);
+		this.name = "CursorMismatchError";
+		Object.setPrototypeOf(this, CursorMismatchError.prototype);
+	}
+};
+/**
+* Tag for a value whose JSON round-trip would otherwise lose its type.
+*
+* A `timestamp` column comes back from the driver as a `Date`; JSON turns it
+* into a string, and the string would then be compared against the column by
+* whatever cast Postgres chose. Round-tripping it as a `Date` keeps the
+* comparison the one the ORDER BY made.
+*/
+var DATE_TAG = "$date";
+function encodeValue(value) {
+	if (value instanceof Date) return { [DATE_TAG]: value.toISOString() };
+	return value;
+}
+function decodeValue(value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const tagged = value[DATE_TAG];
+		if (typeof tagged === "string") {
+			const date = new Date(tagged);
+			return Number.isNaN(date.getTime()) ? tagged : date;
+		}
+	}
+	return value;
+}
+/** base64url, without depending on Node's Buffer (this package runs in browsers). */
+function toBase64Url(text) {
+	const bytes = new TextEncoder().encode(text);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(encoded) {
+	const padded = encoded.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - encoded.length % 4) % 4);
+	const binary = atob(padded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+/**
+* Encode "everything strictly after this row, in this order".
+*
+* @param orderBy the sort keys the listing ran under, in order of significance
+* @param row     the last row served, which the next page picks up after
+* @param id      that row's id — the tiebreaker every keyset comparison ends on
+* @returns the opaque cursor, or `undefined` when no cursor can describe the
+*   page. That is not a failure: a listing sorted by relevance has no stored
+*   value to compare a later page against (scores are computed per query and
+*   are not on the same scale between two of them), so it pages by offset and
+*   `meta.nextCursor` is simply absent.
+*/
+function encodeCursor(orderBy, row, id) {
+	if (id === void 0 || id === null) return void 0;
+	const keys = orderBy ?? [];
+	const values = {};
+	for (const [field] of keys) {
+		if (field in row) {
+			values[field] = encodeValue(row[field]);
+			continue;
+		}
+		if (parseRelationAggregateSort(field)) continue;
+		return;
+	}
+	return toBase64Url(JSON.stringify({
+		k: keys,
+		v: values,
+		i: encodeValue(id)
+	}));
+}
+/**
+* Read a cursor produced by {@link encodeCursor}.
+*
+* @throws {CursorError} when the string is not a cursor this codec wrote.
+*/
+function decodeCursor(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(fromBase64Url(raw.trim()));
+	} catch {
+		throw new CursorError("it is not a cursor this API issued");
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new CursorError("it does not decode to a cursor");
+	const body = parsed;
+	if (!Array.isArray(body.k)) throw new CursorError("it carries no sort keys");
+	if (body.i === void 0) throw new CursorError("it carries no row id");
+	const orderBy = [];
+	for (const entry of body.k) {
+		if (!Array.isArray(entry) || typeof entry[0] !== "string") throw new CursorError("one of its sort keys is malformed");
+		const direction = entry[1] === "desc" ? "desc" : "asc";
+		orderBy.push(entry[2] === "first" || entry[2] === "last" ? [
+			entry[0],
+			direction,
+			entry[2]
+		] : [entry[0], direction]);
+	}
+	const rawValues = body.v && typeof body.v === "object" && !Array.isArray(body.v) ? body.v : {};
+	const values = {};
+	for (const [field, value] of Object.entries(rawValues)) values[field] = decodeValue(value);
+	return {
+		orderBy,
+		values,
+		id: decodeValue(body.i)
+	};
+}
+/**
+* The `orderBy` a request should run under, given a cursor and whatever sort
+* the request itself named.
+*
+* A request that names no sort **adopts the cursor's** — that is what makes
+* `find({ after })` work without restating the `orderBy` from the previous
+* call, and it cannot be wrong, since the cursor is the only sort in play.
+* A request that names one must name the *same* one, key for key, direction for
+* direction, nulls for nulls; anything else is {@link CursorMismatchError}.
+*
+* @throws {CursorMismatchError}
+*/
+function reconcileCursorOrder(cursor, requested) {
+	if (!requested || requested.length === 0) return cursor.orderBy;
+	const spell = (keys) => keys.map(([field, direction, nulls]) => `${field}:${direction}${nulls ? `:${nulls}` : ""}`);
+	const cursorKeys = spell(cursor.orderBy);
+	const queryKeys = spell(requested);
+	if (cursorKeys.length !== queryKeys.length || cursorKeys.some((key, i) => key !== queryKeys[i])) throw new CursorMismatchError(cursorKeys, queryKeys);
+	return requested;
+}
+/**
+* The `startAfter` shape the driver contract takes, built from a cursor.
+*
+* The driver has always accepted `{ id, values }`; this is the one place that
+* shape is produced, so the REST route and the WebSocket ingress cannot drift
+* into two spellings of the same seek.
+*/
+function cursorToStartAfter(cursor) {
+	return {
+		id: cursor.id,
+		values: cursor.values
+	};
+}
+//#endregion
+export { CursorError, CursorMismatchError, cursorToStartAfter, decodeCursor, encodeCursor, reconcileCursorOrder };
+
+//# sourceMappingURL=cursor.es.js.map

package/dist/data/cursor.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.es.js","names":[],"sources":["../../src/data/cursor.ts"],"sourcesContent":["import { parseRelationAggregateSort, type OrderByTuple } from \"@rebasepro/types\";\n\n/**\n * The keyset-cursor wire codec.\n *\n * ## Why this is one module\n *\n * Keyset pagination was implemented three times and reachable once. The driver\n * has a NULL-correct multi-key comparison (`FetchService.buildKeysetComparison`)\n * that only a WebSocket `startAfter` could reach; REST could not seek at all;\n * and the SDK's `iterate({cursor})` re-implemented a *single*-column keyset as a\n * `where` clause, which threw on any multi-key sort and silently dropped rows\n * whose sort value was NULL. Three implementations, three answers to \"what is\n * page two\".\n *\n * There is now one. The driver's comparison is the implementation; this module\n * is the only thing that says how a cursor is written down, and every transport\n * — the REST `?after=`, the WebSocket `startAfter`, the SDK's `iterate()` —\n * carries the string this produces and hands it back unread.\n *\n * ## What a cursor holds\n *\n * The sort keys the query was ordered by, the last served row's value for each\n * of them, and that row's id. The keys travel *with* the values because a\n * cursor that carried only values would be silently reinterpretable: paging a\n * `created_at DESC` listing and then asking for `title ASC` would seek on the\n * dates as though they were titles. Carrying the keys makes that a refusal\n * ({@link CursorMismatchError}) rather than a page of arbitrary rows.\n *\n * ## Opacity\n *\n * The encoding is base64url of JSON, and it is **not** API. It is opaque so it\n * can change — adding a key, changing how a value is tagged — without every\n * client that learned to read it breaking. Nothing outside this file parses it.\n *\n * @module\n */\n\n/** The decoded contents of a cursor. */\nexport interface DecodedCursor {\n    /** The sort keys the cursor was produced under, in order of significance. */\n    orderBy: OrderByTuple[];\n    /** The last served row's value for each sort key, by field name. */\n    values: Record<string, unknown>;\n    /** The last served row's id, which breaks ties on the last key. */\n    id: unknown;\n}\n\n/** A cursor that cannot be read at all — truncated, re-encoded, or invented. */\nexport class CursorError extends Error {\n    readonly code = \"INVALID_CURSOR\";\n    constructor(detail: string) {\n        super(\n            `Invalid \\`after\\` cursor: ${detail}. Pass back the \\`meta.nextCursor\\` ` +\n            \"from the previous page unchanged — it is opaque and must not be built by hand.\"\n        );\n        this.name = \"CursorError\";\n        Object.setPrototypeOf(this, CursorError.prototype);\n    }\n}\n\n/**\n * A cursor that reads fine but describes a different query.\n *\n * Separate from {@link CursorError} because the fix is different: this one is\n * not a corrupt string, it is a correct cursor used against a sort it was not\n * produced under. Seeking anyway would return rows in an order nobody asked\n * for, and — worse — would look like it worked.\n */\nexport class CursorMismatchError extends Error {\n    readonly code = \"CURSOR_ORDER_MISMATCH\";\n    constructor(cursorKeys: string[], queryKeys: string[]) {\n        super(\n            `The \\`after\\` cursor was produced by a query ordered by ` +\n            `${cursorKeys.map(k => `\"${k}\"`).join(\", \") || \"(nothing)\"}, but this query orders by ` +\n            `${queryKeys.map(k => `\"${k}\"`).join(\", \") || \"(nothing)\"}. A cursor only continues the ` +\n            \"listing it came from — keep `orderBy` identical across pages, or drop `after` to start over.\"\n        );\n        this.name = \"CursorMismatchError\";\n        Object.setPrototypeOf(this, CursorMismatchError.prototype);\n    }\n}\n\n/**\n * Tag for a value whose JSON round-trip would otherwise lose its type.\n *\n * A `timestamp` column comes back from the driver as a `Date`; JSON turns it\n * into a string, and the string would then be compared against the column by\n * whatever cast Postgres chose. Round-tripping it as a `Date` keeps the\n * comparison the one the ORDER BY made.\n */\nconst DATE_TAG = \"$date\";\n\nfunction encodeValue(value: unknown): unknown {\n    if (value instanceof Date) return { [DATE_TAG]: value.toISOString() };\n    return value;\n}\n\nfunction decodeValue(value: unknown): unknown {\n    if (value && typeof value === \"object\" && !Array.isArray(value)) {\n        const tagged = (value as Record<string, unknown>)[DATE_TAG];\n        if (typeof tagged === \"string\") {\n            const date = new Date(tagged);\n            return Number.isNaN(date.getTime()) ? tagged : date;\n        }\n    }\n    return value;\n}\n\n/** base64url, without depending on Node's Buffer (this package runs in browsers). */\nfunction toBase64Url(text: string): string {\n    const bytes = new TextEncoder().encode(text);\n    let binary = \"\";\n    for (const byte of bytes) binary += String.fromCharCode(byte);\n    return btoa(binary).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\nfunction fromBase64Url(encoded: string): string {\n    const padded = encoded.replace(/-/g, \"+\").replace(/_/g, \"/\")\n        + \"=\".repeat((4 - (encoded.length % 4)) % 4);\n    const binary = atob(padded);\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);\n    return new TextDecoder().decode(bytes);\n}\n\n/**\n * Encode \"everything strictly after this row, in this order\".\n *\n * @param orderBy the sort keys the listing ran under, in order of significance\n * @param row     the last row served, which the next page picks up after\n * @param id      that row's id — the tiebreaker every keyset comparison ends on\n * @returns the opaque cursor, or `undefined` when no cursor can describe the\n *   page. That is not a failure: a listing sorted by relevance has no stored\n *   value to compare a later page against (scores are computed per query and\n *   are not on the same scale between two of them), so it pages by offset and\n *   `meta.nextCursor` is simply absent.\n */\nexport function encodeCursor(\n    orderBy: OrderByTuple[] | undefined,\n    row: Record<string, unknown>,\n    id: unknown\n): string | undefined {\n    if (id === undefined || id === null) return undefined;\n    const keys = orderBy ?? [];\n    // A key whose value is not on the row cannot be seeked past. Rather than\n    // emit a cursor that the next request would refuse, emit none — the caller\n    // falls back to offset paging, which is what it did before cursors existed.\n    //\n    // An aggregate over a relation (`count(orders)`) is the exception: it is\n    // never on the row, and it needs no value here, because the keyset\n    // comparison recomputes the cursor row's value in SQL from the id.\n    // Refusing it withheld the cursor from every such listing.\n    const values: Record<string, unknown> = {};\n    for (const [field] of keys) {\n        if (field in row) {\n            values[field] = encodeValue(row[field]);\n            continue;\n        }\n        if (parseRelationAggregateSort(field)) continue;\n        return undefined;\n    }\n    return toBase64Url(JSON.stringify({ k: keys, v: values, i: encodeValue(id) }));\n}\n\n/**\n * Read a cursor produced by {@link encodeCursor}.\n *\n * @throws {CursorError} when the string is not a cursor this codec wrote.\n */\nexport function decodeCursor(raw: string): DecodedCursor {\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(fromBase64Url(raw.trim()));\n    } catch {\n        throw new CursorError(\"it is not a cursor this API issued\");\n    }\n    if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) {\n        throw new CursorError(\"it does not decode to a cursor\");\n    }\n    const body = parsed as { k?: unknown; v?: unknown; i?: unknown };\n    if (!Array.isArray(body.k)) throw new CursorError(\"it carries no sort keys\");\n    if (body.i === undefined) throw new CursorError(\"it carries no row id\");\n\n    const orderBy: OrderByTuple[] = [];\n    for (const entry of body.k) {\n        if (!Array.isArray(entry) || typeof entry[0] !== \"string\") {\n            throw new CursorError(\"one of its sort keys is malformed\");\n        }\n        const direction = entry[1] === \"desc\" ? \"desc\" : \"asc\";\n        orderBy.push(entry[2] === \"first\" || entry[2] === \"last\"\n            ? [entry[0], direction, entry[2]]\n            : [entry[0], direction]);\n    }\n\n    const rawValues = (body.v && typeof body.v === \"object\" && !Array.isArray(body.v))\n        ? body.v as Record<string, unknown>\n        : {};\n    const values: Record<string, unknown> = {};\n    for (const [field, value] of Object.entries(rawValues)) values[field] = decodeValue(value);\n\n    return { orderBy, values, id: decodeValue(body.i) };\n}\n\n/**\n * The `orderBy` a request should run under, given a cursor and whatever sort\n * the request itself named.\n *\n * A request that names no sort **adopts the cursor's** — that is what makes\n * `find({ after })` work without restating the `orderBy` from the previous\n * call, and it cannot be wrong, since the cursor is the only sort in play.\n * A request that names one must name the *same* one, key for key, direction for\n * direction, nulls for nulls; anything else is {@link CursorMismatchError}.\n *\n * @throws {CursorMismatchError}\n */\nexport function reconcileCursorOrder(\n    cursor: DecodedCursor,\n    requested: OrderByTuple[] | undefined\n): OrderByTuple[] {\n    if (!requested || requested.length === 0) return cursor.orderBy;\n    const spell = (keys: OrderByTuple[]) =>\n        keys.map(([field, direction, nulls]) => `${field}:${direction}${nulls ? `:${nulls}` : \"\"}`);\n    const cursorKeys = spell(cursor.orderBy);\n    const queryKeys = spell(requested);\n    if (cursorKeys.length !== queryKeys.length\n        || cursorKeys.some((key, i) => key !== queryKeys[i])) {\n        throw new CursorMismatchError(cursorKeys, queryKeys);\n    }\n    return requested;\n}\n\n/**\n * The `startAfter` shape the driver contract takes, built from a cursor.\n *\n * The driver has always accepted `{ id, values }`; this is the one place that\n * shape is produced, so the REST route and the WebSocket ingress cannot drift\n * into two spellings of the same seek.\n */\nexport function cursorToStartAfter(cursor: DecodedCursor): Record<string, unknown> {\n    return { id: cursor.id, values: cursor.values };\n}\n"],"mappings":"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"}

package/dist/data/filter-conditions.es.js

@@ -0,0 +1,24 @@
+//#region src/data/filter-conditions.ts
+/**
+* Read one field's filter as the list of conditions it stands for.
+*
+* Accepts both declared shapes and normalises them to a list:
+*
+* ```ts
+* toFilterTuples(["==", "active"])          // [["==", "active"]]
+* toFilterTuples([[">=", 18], ["<", 65]])   // [[">=", 18], ["<", 65]]
+* ```
+*
+* A falsy, non-array or empty param has no conditions in it — the empty list,
+* so a caller iterating adds nothing rather than compiling a tuple of
+* `undefined`s and logging about an operator nobody sent.
+*/
+function toFilterTuples(filterParam) {
+	if (!filterParam || !Array.isArray(filterParam) || filterParam.length === 0) return [];
+	if (Array.isArray(filterParam[0])) return filterParam;
+	return [filterParam];
+}
+//#endregion
+export { toFilterTuples };
+
+//# sourceMappingURL=filter-conditions.es.js.map

package/dist/data/filter-conditions.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-conditions.es.js","names":[],"sources":["../../src/data/filter-conditions.ts"],"sourcesContent":["/**\n * The `FilterValues` grammar, one level below the wire codec.\n *\n * A field's filter is either one `[op, value]` tuple or an **array** of them —\n * `{ age: [[\">=\", 18], [\"<\", 65]] }` — which is what the fluent builder produces\n * from two `.where()` calls on the same column. Reading that shape is grammar,\n * not a driver detail, so every compiler reads it through here.\n *\n * It lived only inside the Postgres compiler, and the Mongo one destructured\n * `const [op, value] = filterParam` regardless: given the array-of-tuples form\n * `op` bound to `[\">=\", 18]`, no operator matched, and the condition was\n * dropped. Both of them. A read asking for adults under 65 returned every row\n * of the collection with a 200.\n *\n * @module\n */\n\nimport type { WhereFilterOp } from \"@rebasepro/types\";\n\n/** One `[operator, value]` condition. */\nexport type FilterTuple = [WhereFilterOp, unknown];\n\n/**\n * Read one field's filter as the list of conditions it stands for.\n *\n * Accepts both declared shapes and normalises them to a list:\n *\n * ```ts\n * toFilterTuples([\"==\", \"active\"])          // [[\"==\", \"active\"]]\n * toFilterTuples([[\">=\", 18], [\"<\", 65]])   // [[\">=\", 18], [\"<\", 65]]\n * ```\n *\n * A falsy, non-array or empty param has no conditions in it — the empty list,\n * so a caller iterating adds nothing rather than compiling a tuple of\n * `undefined`s and logging about an operator nobody sent.\n */\nexport function toFilterTuples(filterParam: unknown): FilterTuple[] {\n    if (!filterParam || !Array.isArray(filterParam) || filterParam.length === 0) return [];\n    // The first element discriminates: a condition starts with an operator\n    // string, a list of conditions starts with a condition. `[\"in\", [\"a\",\"b\"]]`\n    // is one condition whose value happens to be a list.\n    if (Array.isArray(filterParam[0])) {\n        return filterParam as FilterTuple[];\n    }\n    return [filterParam as FilterTuple];\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoCA,SAAgB,eAAe,aAAqC;CAChE,IAAI,CAAC,eAAe,CAAC,MAAM,QAAQ,WAAW,KAAK,YAAY,WAAW,GAAG,OAAO,CAAC;CAIrF,IAAI,MAAM,QAAQ,YAAY,EAAE,GAC5B,OAAO;CAEX,OAAO,CAAC,WAA0B;AACtC"}

package/dist/data/filter-dialect.d.ts

@@ -66,9 +66,9 @@ export declare class UnknownFilterOperatorError extends Error {
 }
 /**
  * The query-parameter names a REST listing reads as something other than a
- * field filter: pagination, sorting, includes, projection, search, the logical
- * groups, the JSON `where` dialect, an aggregate's `select`/`groupBy`, and the
- * soft-delete switches.
+ * field filter: pagination and whether to count, sorting, includes,
+ * projection, search, the logical groups, the JSON `where` dialect, an
+ * aggregate's `select`/`groupBy`, and the soft-delete switches.
  *
  * One list for both ends. The server skips these names when it collects
  * `?<field>=<op>.<value>` filters, and the SDK sends a filter on a column with