@rebasepro/server 0.14.0 → 0.14.1

package/dist/services/webhook-service.d.ts

@@ -1,3 +1,12 @@
+import type { JobQueueClient } from "../jobs/types";
+/**
+ * The task name a queued webhook delivery is stored under.
+ *
+ * Namespaced, and frozen: it is written into `rebase.jobs` rows that outlive
+ * the deploy that wrote them, so renaming it would strand every delivery
+ * already queued under the old name until they dead-lettered.
+ */
+export declare const WEBHOOK_DELIVERY_TASK = "rebase.webhook.deliver";
 export interface WebhookConfig {
     id: string;
     url: string;
@@ -43,6 +52,14 @@ export interface WebhookDispatcherOptions {
      * `dns.lookup`; injected by tests so a unit suite never asks a resolver.
      */
     lookup?: (hostname: string) => Promise<string[]>;
+    /**
+     * Where {@link WebhookDispatcher.enqueueEntityChange} puts deliveries.
+     *
+     * Without it they go to an in-memory array that a crash or a deploy
+     * empties. With it they are rows, retried with backoff by a worker that
+     * may not even be the process that queued them.
+     */
+    jobQueue?: JobQueueClient;
 }
 export declare class WebhookDispatcher {
     private webhooks;
@@ -77,16 +94,37 @@ export declare class WebhookDispatcher {
      * for a third party. It also means a receiver that is down can no longer
      * fail the customer's write.
      *
-     * The cost, stated plainly: the queue is in-process and in-memory. A crash
-     * or a deploy between the enqueue and the delivery drops the event, and a
-     * receiver may see the notification a few milliseconds before the row it
-     * describes is committed. Use {@link flush} on shutdown, and
-     * `onDelivery` to record failures.
+     * The cost, when no `jobQueue` is configured: the queue is in-process and
+     * in-memory. A crash or a deploy between the enqueue and the delivery drops
+     * the event, and a receiver may see the notification a few milliseconds
+     * before the row it describes is committed. Use {@link flush} on shutdown,
+     * and `onDelivery` to record failures.
+     *
+     * With `jobQueue` set, only the second half of that remains: the delivery
+     * becomes a row in `rebase.jobs` and survives the crash, the deploy and the
+     * pod being rescheduled.
      */
     enqueueEntityChange(table: string, event: "INSERT" | "UPDATE" | "DELETE", id: string, entity: Record<string, unknown> | null, previousEntity?: Record<string, unknown> | null): void;
+    /**
+     * Deliver one queued job, as the worker runs it.
+     *
+     * One attempt, and it throws on failure. The retries belong to the queue
+     * now: keeping both would multiply — three in-process attempts inside each
+     * of three job attempts is nine deliveries and about two minutes of holding
+     * a worker slot — and only the queue's retries survive a restart, which is
+     * the whole reason for moving.
+     */
+    deliverQueuedJob(job: {
+        webhookId: string;
+        event: string;
+        payload: Record<string, unknown>;
+    }): Promise<void>;
     /**
      * Wait for every queued delivery to finish. For graceful shutdown, and for
      * tests that need to observe what {@link enqueueEntityChange} sent.
+     *
+     * In-process deliveries only — with a `jobQueue` configured there is
+     * nothing here to wait for, because the deliveries are rows.
      */
     flush(): Promise<void>;
     private startDraining;

package/dist/{src-C7rkDGxA.js → src-8XDWyDfR.js}

@@ -3078,6 +3078,70 @@ var CollectionRegistry = class {
 	}
 };
 //#endregion
+//#region ../common/src/data/sort-dialect.ts
+/**
+* Sort-order wire codec.
+*
+* This is the ONLY module that knows about the colon-delimited wire format
+* (`"field:direction"`) used in HTTP query parameters, and about the JSON-array
+* form that carries a multi-column sort over the same parameter.
+* Everything else speaks {@link OrderByTuple} exclusively.
+*
+* Mirrors the filter architecture in `filter-dialect.ts`.
+*
+* @module
+*/
+/**
+* Collapse the one-key and many-key spellings of a sort into the list form.
+*
+* `["a", "desc"]` and `[["a", "desc"]]` mean the same thing and normalize to
+* the same value; the two are told apart by whether the first element is
+* itself an array, which no field name ever is.
+*
+* @returns The keys in order of significance, or `undefined` for no sort. An
+*   empty list also returns `undefined` — "sort by nothing" is no sort, and
+*   letting `[]` through would have every layer below re-deciding what it meant.
+*/
+function normalizeOrderBy(orderBy) {
+	if (!orderBy || orderBy.length === 0) return void 0;
+	const list = Array.isArray(orderBy[0]) ? orderBy : [orderBy];
+	return list.length > 0 ? list : void 0;
+}
+/**
+* Serialize a sort to the wire.
+*
+* A single key keeps the `"field:direction"` shorthand it has always used —
+* short, readable in a URL, and what every existing client and test expects.
+* Several keys are emitted as the canonical JSON array the server already
+* accepts, because the shorthand has no separator to spare: a comma-joined
+* `"a:asc,b:desc"` parses as one field named `a` with the direction
+* `"asc,b:desc"`, which the server refuses.
+*
+* **Runtime tolerance:** if the input is already a well-formed wire string
+* (from an untyped JS caller), it is returned unchanged.
+* This is undocumented tolerance, not public API — don't rely on it.
+*
+* @param orderBy - A canonical tuple or list of tuples, or at runtime
+*   possibly a pre-serialized string (undocumented tolerance).
+* @returns The wire-format string, or `undefined` if the input is falsy.
+*
+* @remarks
+* Field names containing `:` are representable in the tuple form but
+* **not** in the single-key wire encoding — this is an inherent limitation of
+* the colon-delimited shorthand and is not resolved here.
+*/
+function serializeOrderBy(orderBy) {
+	if (!orderBy) return void 0;
+	if (typeof orderBy === "string") return orderBy;
+	const list = normalizeOrderBy(orderBy);
+	if (!list) return void 0;
+	if (list.length === 1) return `${list[0][0]}:${list[0][1]}`;
+	return JSON.stringify(list.map(([field, direction]) => ({
+		field,
+		direction
+	})));
+}
+//#endregion
 //#region ../common/src/data/query_builder.ts
 var QueryBuilder = class {
 	collection;
@@ -3106,11 +3170,18 @@ var QueryBuilder = class {
 	}
 	/**
 	* Order the results by a specific column.
+	*
+	* Called again, this adds a tie-breaker rather than replacing the sort:
+	* keys apply in the order they were added.
+	*
 	* @example
 	* client.collection('users').orderBy('createdAt', 'desc').find()
+	* @example
+	* client.collection('users').orderBy('roles').orderBy('createdAt', 'desc').find()
 	*/
 	orderBy(column, direction = "asc") {
-		this.params.orderBy = [column, direction];
+		const existing = normalizeOrderBy(this.params.orderBy) ?? [];
+		this.params.orderBy = [...existing, [column, direction]];
 		return this;
 	}
 	/**
@@ -3284,9 +3355,10 @@ async function* paginateFind(find, params, label = "collection") {
 	const requestedDirection = typeof cursor === "object" && cursor !== null ? cursor.direction : void 0;
 	let direction = "asc";
 	if (cursorField) {
-		const orderBy = findParams.orderBy;
-		if (orderBy && orderBy[0] !== cursorField) throw new RebasePaginationError("cursor-order-mismatch", `Cannot seek on "${cursorField}" while ordering "${label}" by "${orderBy[0]}": keyset pagination only advances along the column the query is sorted by. Order by "${cursorField}", or drop the cursor and page by offset.`);
-		direction = requestedDirection ?? orderBy?.[1] ?? "asc";
+		const orderBy = normalizeOrderBy(findParams.orderBy);
+		if (orderBy && orderBy.length > 1) throw new RebasePaginationError("cursor-order-mismatch", `Cannot seek on "${cursorField}" while ordering "${label}" by ${orderBy.map(([field]) => `"${field}"`).join(", ")}: keyset pagination advances along a single column. Order by "${cursorField}" alone, or drop the cursor and page by offset.`);
+		if (orderBy && orderBy[0][0] !== cursorField) throw new RebasePaginationError("cursor-order-mismatch", `Cannot seek on "${cursorField}" while ordering "${label}" by "${orderBy[0][0]}": keyset pagination only advances along the column the query is sorted by. Order by "${cursorField}", or drop the cursor and page by offset.`);
+		direction = requestedDirection ?? orderBy?.[0][1] ?? "asc";
 		findParams.orderBy = [cursorField, direction];
 	}
 	const seekOp = direction === "desc" ? "<" : ">";
@@ -3936,8 +4008,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				logical: params?.logical,
 				limit,
 				offset: driverOffset,
-				orderBy: params?.orderBy?.[0],
-				order: params?.orderBy?.[1],
+				orderBy: normalizeOrderBy(params?.orderBy),
 				searchString: params?.searchString
 			}, params?.include) : await driver.fetchCollection({
 				path: slug,
@@ -3945,8 +4016,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				offset: driverOffset,
 				filter,
 				logical: params?.logical,
-				orderBy: params?.orderBy?.[0],
-				order: params?.orderBy?.[1],
+				orderBy: normalizeOrderBy(params?.orderBy),
 				searchString: params?.searchString
 			});
 			let total = rows.length + offset;
@@ -4041,8 +4111,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				offset: driverOffset,
 				filter: params?.where,
 				logical: params?.logical,
-				orderBy: params?.orderBy?.[0],
-				order: params?.orderBy?.[1],
+				orderBy: normalizeOrderBy(params?.orderBy),
 				searchString: params?.searchString,
 				searchExplain: params?.searchExplain,
 				onUpdate: (entities) => {
@@ -4162,8 +4231,10 @@ var SdkQueryBuilder = class {
 		}
 		return this;
 	}
+	/** Called again, this adds a tie-breaker rather than replacing the sort. */
 	orderBy(column, direction = "asc") {
-		this.params.orderBy = [column, direction];
+		const existing = normalizeOrderBy(this.params.orderBy) ?? [];
+		this.params.orderBy = [...existing, [column, direction]];
 		return this;
 	}
 	limit(count) {
@@ -4361,6 +4432,6 @@ function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
 	} });
 }
 //#endregion
-export { RebaseApiError as A, resolveClientListLimit as C, EntityRelation as D, EntityReference as E, GeoPoint as O, MAX_LIST_LIMIT as S, isAnonymousUid as T, resolveCollectionRelations as _, deserializeLogicalCondition as a, toSnakeCase as b, collectAllPages as c, CollectionRegistry as d, createDataSourceRegistry as f, findRelation as g, fieldKeyForColumn as h, deserializeFilter as i, RebaseClientError as j, Vector as k, paginateFind as l, getEffectiveSecurityRules as m, buildSdkData as n, serializeFilter as o, resolveDataSource as p, UnknownFilterOperatorError as r, serializeLogicalCondition as s, buildRoutedRebaseData as t, resolveFindWindow as u, buildCompositeId as v, ANONYMOUS_USER_ID as w, ListLimitError as x, resolvePrimaryKeys as y };
+export { GeoPoint as A, ListLimitError as C, isAnonymousUid as D, ANONYMOUS_USER_ID as E, RebaseApiError as M, RebaseClientError as N, EntityReference as O, toSnakeCase as S, resolveClientListLimit as T, fieldKeyForColumn as _, deserializeLogicalCondition as a, buildCompositeId as b, collectAllPages as c, normalizeOrderBy as d, serializeOrderBy as f, getEffectiveSecurityRules as g, resolveDataSource as h, deserializeFilter as i, Vector as j, EntityRelation as k, paginateFind as l, createDataSourceRegistry as m, buildSdkData as n, serializeFilter as o, CollectionRegistry as p, UnknownFilterOperatorError as r, serializeLogicalCondition as s, buildRoutedRebaseData as t, resolveFindWindow as u, findRelation as v, MAX_LIST_LIMIT as w, resolvePrimaryKeys as x, resolveCollectionRelations as y };
 
-//# sourceMappingURL=src-C7rkDGxA.js.map
+//# sourceMappingURL=src-8XDWyDfR.js.map