@rebasepro/server-postgres 0.11.1-canary.gf2b0ff7 → 0.11.1-canary.gfadf355

package/dist/{src-3VmUJ8Xn.js → src-Cn0_95uv.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "module";
 import "process";
 __createRequire(import.meta.url);
 import { r as __require, t as __commonJSMin } from "./chunk-DSJWtz9O.js";
-import { d as isPostgresCollectionConfig, f as NULL_OPS, h as EntityRelation, l as isManyToMany, m as toCanonicalOp, n as getDataSourceCapabilities, o as ANONYMOUS_USER_ID, p as REST_TO_CANONICAL, s as policy, u as getDeclaredSubcollections } from "./src-D5xBTl32.js";
+import { d as isPostgresCollectionConfig, f as NULL_OPS, h as EntityRelation, l as isManyToMany, m as toCanonicalOp, n as getDataSourceCapabilities, o as ANONYMOUS_USER_ID, p as REST_TO_CANONICAL, s as policy, u as getDeclaredSubcollections } from "./src-C5hyt1Um.js";
 //#region ../common/src/util/common.ts
 var DEFAULT_ONE_OF_TYPE = "type";
 var DEFAULT_ONE_OF_VALUE = "value";
@@ -1264,7 +1264,7 @@ function traverseValueProperty(inputValue, property, operation) {
 	return value;
 }
 /**
-* Create a lightweight relation stub for CMS views.
+* Create a lightweight relation stub for admin views.
 * Replaces inline `{ id, path, __type: "relation" }` object literals.
 */
 function createRelationRef(id, path) {
@@ -3444,6 +3444,136 @@ var QueryBuilder = class {
 		return this.collection.listen(this.params, onUpdate, onError);
 	}
 };
+/** Rows `findAll()` will materialise before it refuses to continue. */
+var DEFAULT_FIND_ALL_MAX_ROWS = 1e4;
+/**
+* Requests one walk may make before it gives up on the server ever saying
+* `hasMore: false`. At the default page size that is two million rows — far
+* past any legitimate walk, and short of running forever.
+*/
+var DEFAULT_MAX_PAGES = 1e4;
+/**
+* Thrown when a walk stops for a reason the caller needs to know about.
+*
+* Every one of these is a case where the alternative would be silent: a
+* truncated array that looks complete, or a loop that never returns. Check
+* {@link code} to tell them apart.
+*/
+var RebasePaginationError = class RebasePaginationError extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "RebasePaginationError";
+		this.code = code;
+		Object.setPrototypeOf(this, RebasePaginationError.prototype);
+	}
+};
+function normalizePageSize(raw) {
+	if (raw === void 0 || !Number.isFinite(raw)) return 200;
+	return Math.max(1, Math.floor(raw));
+}
+function normalizeMaxPages(raw) {
+	if (raw === void 0) return DEFAULT_MAX_PAGES;
+	if (raw === Number.POSITIVE_INFINITY) return raw;
+	if (!Number.isFinite(raw)) return DEFAULT_MAX_PAGES;
+	return Math.max(1, Math.floor(raw));
+}
+function normalizeMaxRows(raw) {
+	if (raw === void 0) return DEFAULT_FIND_ALL_MAX_ROWS;
+	if (raw === Number.POSITIVE_INFINITY) return raw;
+	if (!Number.isFinite(raw)) return DEFAULT_FIND_ALL_MAX_ROWS;
+	return Math.max(0, Math.floor(raw));
+}
+/**
+* Add one condition to a `where` map without disturbing what is already there.
+*
+* The caller's own filter on the cursor column has to survive — dropping it
+* would widen the query, which is the silent-filter-loss failure mode — so a
+* second condition on the same column becomes the array-of-tuples form that
+* `FindParams.where` already accepts, and both are AND-ed.
+*/
+function appendCondition(where, column, condition) {
+	const next = { ...where ?? {} };
+	const existing = next[column];
+	if (existing === void 0) next[column] = condition;
+	else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) next[column] = [...existing, condition];
+	else next[column] = [existing, condition];
+	return next;
+}
+function cursorEquals(a, b) {
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	return Object.is(a, b);
+}
+/**
+* Walk every row a query matches, yielding one row at a time and fetching the
+* next page only when the consumer asks for it.
+*
+* See {@link SDKCollectionClient.iterate} for the caller-facing contract,
+* including the offset-drift caveat and the `cursor` alternative.
+*
+* @param find   the transport's single-page read
+* @param params `find()` parameters minus the window, plus the walk options
+* @param label  the collection name, so an error says which walk failed
+*/
+async function* paginateFind(find, params, label = "collection") {
+	const { pageSize, cursor, maxPages, ...rest } = params ?? {};
+	const findParams = { ...rest };
+	const size = normalizePageSize(pageSize);
+	const pageCap = normalizeMaxPages(maxPages);
+	const cursorField = typeof cursor === "string" ? cursor : cursor?.field;
+	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";
+		findParams.orderBy = [cursorField, direction];
+	}
+	const seekOp = direction === "desc" ? "<" : ">";
+	const baseWhere = findParams.where;
+	let offset = 0;
+	let pages = 0;
+	let cursorValue;
+	let seeking = false;
+	for (;;) {
+		if (pages >= pageCap) throw new RebasePaginationError("max-pages", `Iterating "${label}" made ${pages} requests without the server reporting the end of the collection. Stopping rather than looping forever — raise \`maxPages\` if the walk is genuinely this long, or check that the backend sets \`meta.hasMore\`.`);
+		const pageParams = {
+			...findParams,
+			limit: size
+		};
+		if (cursorField) {
+			if (seeking) pageParams.where = appendCondition(baseWhere, cursorField, [seekOp, cursorValue]);
+		} else pageParams.offset = offset;
+		const page = await find(pageParams);
+		pages += 1;
+		const rows = page?.data ?? [];
+		if (rows.length === 0) return;
+		for (const row of rows) yield row;
+		if (page?.meta?.hasMore !== true) return;
+		if (cursorField) {
+			const nextValue = rows[rows.length - 1]?.[cursorField];
+			if (nextValue === void 0 || nextValue === null) throw new RebasePaginationError("cursor-missing", `Cannot seek past the last row of "${label}": it has no value for the cursor column "${cursorField}". Pick a column that is present and non-null on every row.`);
+			if (seeking && cursorEquals(nextValue, cursorValue)) throw new RebasePaginationError("cursor-stalled", `Iterating "${label}" is stuck: two pages in a row ended at ${cursorField}=${String(nextValue)}. The cursor column has to be unique — a repeated value cannot be seeked past, and continuing would either loop forever or skip the duplicates. Use the primary key, or page by offset.`);
+			cursorValue = nextValue;
+			seeking = true;
+		} else offset += rows.length;
+	}
+}
+/**
+* {@link paginateFind}, collected into an array under a ceiling.
+*
+* See {@link SDKCollectionClient.findAll}.
+*/
+async function collectAllPages(find, params, label = "collection") {
+	const { maxRows, ...rest } = params ?? {};
+	const cap = normalizeMaxRows(maxRows);
+	const out = [];
+	for await (const row of paginateFind(find, rest, label)) {
+		out.push(row);
+		if (out.length > cap) throw new RebasePaginationError("max-rows", `findAll("${label}") matched more than ${cap} rows. Returning the first ${cap} would look like the whole answer and quietly not be one, so this throws instead. Raise \`maxRows\` if you meant to load them all, or stream with \`iterate()\`.`);
+	}
+	return out;
+}
 //#endregion
 //#region ../common/src/data/filter-dialect.ts
 /**
@@ -3593,6 +3723,42 @@ function rowToEntity(row, slug, primaryKeys = []) {
 		values: row
 	};
 }
+/**
+* The relation envelope `toCmsRow` writes where a relation was:
+* `{ id, path, __type: "relation", data: { id, path, values } }`. It is the
+* admin's view-model, and the only pipeline that produces one is postgres'.
+*/
+function isRelationEnvelope(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && value.__type === "relation";
+}
+/** The target's own columns, as `toRestRow` would have inlined them. */
+function inlineEnvelope(envelope) {
+	return envelope.data?.values ?? {};
+}
+/**
+* Replace every relation envelope on a row with the target's flat columns.
+*
+* The SDK serves one relation shape — the inlined one (see
+* {@link RestFetchService}) — and reads that come back through a *driver*
+* method rather than the REST pipeline still carry envelopes. Realtime is the
+* one such read left: there is no `listenForRest`, so the rows arrive shaped
+* for the admin and are flattened here instead.
+*
+* Only applied where the REST pipeline is the contract (see `find`); a driver
+* without a `restFetchService` keeps whatever it returns, so the admin's own
+* path through {@link buildRebaseData} is untouched.
+*/
+function inlineRelationRefs(row) {
+	let out;
+	for (const [key, value] of Object.entries(row)) if (isRelationEnvelope(value)) {
+		out = out ?? { ...row };
+		out[key] = inlineEnvelope(value);
+	} else if (Array.isArray(value) && value.some(isRelationEnvelope)) {
+		out = out ?? { ...row };
+		out[key] = value.map((item) => isRelationEnvelope(item) ? inlineEnvelope(item) : item);
+	}
+	return out ?? row;
+}
 function createDriverAccessor(driver, slug, getPks = () => []) {
 	const accessor = {
 		async find(params) {
@@ -3600,14 +3766,14 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 			const limit = params?.limit ?? 20;
 			const offset = params?.offset ?? 0;
 			const fetchService = driver.restFetchService;
-			const rows = fetchService && params?.include && params.include.length > 0 ? await fetchService.fetchCollectionForRest(slug, {
+			const rows = fetchService ? await fetchService.fetchCollectionForRest(slug, {
 				filter,
 				limit: params?.limit,
 				offset: params?.offset,
 				orderBy: params?.orderBy?.[0],
 				order: params?.orderBy?.[1],
 				searchString: params?.searchString
-			}, params.include) : await driver.fetchCollection({
+			}, params?.include) : await driver.fetchCollection({
 				path: slug,
 				limit: params?.limit,
 				offset: params?.offset,
@@ -3636,7 +3802,8 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 			};
 		},
 		async findById(id) {
-			const row = await driver.fetchOne({
+			const fetchService = driver.restFetchService;
+			const row = fetchService ? await fetchService.fetchOneForRest(slug, id) : await driver.fetchOne({
 				path: slug,
 				id
 			});
@@ -3682,6 +3849,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 		listen: driver.listenCollection ? (params, onUpdate, onError) => {
 			const limit = params?.limit ?? 20;
 			const offset = params?.offset ?? 0;
+			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
 			return driver.listenCollection({
 				path: slug,
 				limit: params?.limit,
@@ -3692,7 +3860,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				searchString: params?.searchString,
 				onUpdate: (entities) => {
 					onUpdate({
-						data: entities.map((row) => rowToEntity(row, slug, getPks())),
+						data: entities.map((row) => rowToEntity(normalize(row), slug, getPks())),
 						meta: {
 							total: entities.length,
 							limit,
@@ -3705,10 +3873,11 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 			});
 		} : void 0,
 		listenById: driver.listenOne ? (id, onUpdate, onError) => {
+			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
 			return driver.listenOne({
 				path: slug,
 				id,
-				onUpdate: (entity) => onUpdate(entity ? rowToEntity(entity, slug, getPks()) : void 0),
+				onUpdate: (entity) => onUpdate(entity ? rowToEntity(normalize(entity), slug, getPks()) : void 0),
 				onError
 			});
 		} : void 0,
@@ -3839,7 +4008,7 @@ var SdkQueryBuilder = class {
 * {@link SDKCollectionClient}. Every returned record is unwrapped to a flat row
 * so the backend SDK is byte-for-byte the same shape as the frontend client.
 */
-function toSdkCollectionClient(snap) {
+function toSdkCollectionClient(snap, slug = "collection") {
 	const client = {
 		async find(params) {
 			const res = await snap.find(params);
@@ -3848,6 +4017,12 @@ function toSdkCollectionClient(snap) {
 				meta: res.meta
 			};
 		},
+		iterate(params) {
+			return paginateFind((p) => client.find(p), params, slug);
+		},
+		findAll(params) {
+			return collectAllPages((p) => client.find(p), params, slug);
+		},
 		async findById(id) {
 			const s = await snap.findById(id);
 			return s ? entityToRow(s) : void 0;
@@ -3899,7 +4074,7 @@ function wrapAsSdkData(entityData) {
 	function getAccessor(slug) {
 		let accessor = cache.get(slug);
 		if (!accessor) {
-			accessor = toSdkCollectionClient(entityData.collection(slug));
+			accessor = toSdkCollectionClient(entityData.collection(slug), slug);
 			cache.set(slug, accessor);
 		}
 		return accessor;
@@ -3916,8 +4091,12 @@ function wrapAsSdkData(entityData) {
 *
 * This is the developer-facing SDK data layer used by backend framework
 * callbacks & scripts (`context.data` / `rebase.data`). It returns flat rows —
-* identical in shape to the frontend SDK client — so the API is symmetric
-* across front and back. The admin CMS uses {@link buildRebaseData} (Entity).
+* identical in shape to the frontend SDK client, down to how a relation is
+* served: a foreign key stays a foreign key, and a relation named in `include`
+* arrives as the target's own columns. The `{ __type: "relation" }` envelope is
+* the admin's view-model and never reaches here.
+*
+* The admin uses {@link buildRebaseData} (Entity) over its own driver.
 */
 function buildSdkData(driver) {
 	return wrapAsSdkData(buildRebaseData(driver));
@@ -3989,6 +4168,6 @@ async function detectJunctionTables(executeSql) {
 	return junctionTables;
 }
 //#endregion
-export { DEFAULT_ONE_OF_TYPE as A, createRelationRefWithData as C, mergeDeep as D, getPolicyNamesForRule as E, camelCase as O, createRelationRef as S, updateDateAutoValues as T, getTableVarName as _, getJunctionCollectionConfig as a, getDeclaredPrimaryKeys as b, getEffectiveSecurityRules as c, securityRuleToConditions as d, findAnonymousGrants as f, getTableName as g, getEnumVarName as h, CollectionRegistry as i, DEFAULT_ONE_OF_VALUE as j, toSnakeCase as k, buildPropertyCallbacks as l, getColumnName as m, detectJunctionTables as n, getJunctionSecurityRules as o, findRelation as p, buildSdkData as r, resolveJunctionSpecs as s, classifyTable as t, policyToPostgres as u, resolveCollectionRelations as v, normalizeToEntityRelation as w, parseIdValues as x, buildCompositeId as y };
+export { toSnakeCase as A, createRelationRefWithData as C, getPolicyNamesForRule as D, generateForeignKeyName as E, DEFAULT_ONE_OF_VALUE as M, mergeDeep as O, createRelationRef as S, updateDateAutoValues as T, getTableVarName as _, getJunctionCollectionConfig as a, getDeclaredPrimaryKeys as b, getEffectiveSecurityRules as c, securityRuleToConditions as d, findAnonymousGrants as f, getTableName as g, getEnumVarName as h, CollectionRegistry as i, DEFAULT_ONE_OF_TYPE as j, camelCase as k, buildPropertyCallbacks as l, getColumnName as m, detectJunctionTables as n, getJunctionSecurityRules as o, findRelation as p, buildSdkData as r, resolveJunctionSpecs as s, classifyTable as t, policyToPostgres as u, resolveCollectionRelations as v, normalizeToEntityRelation as w, parseIdValues as x, buildCompositeId as y };
 
-//# sourceMappingURL=src-3VmUJ8Xn.js.map
+//# sourceMappingURL=src-Cn0_95uv.js.map