@rebasepro/server-postgres 0.11.1-canary.gfd39654 → 0.12.1-canary.g009ed95

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

@@ -1,8 +1,61 @@
 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 { l as __require, s as __commonJSMin } from "./connection-BuZ97wsr.js";
+import { a as getDataSourceCapabilities, c as toCanonicalOp, n as isPostgresCollectionConfig, o as NULL_OPS, r as isRelationalCollectionConfig, s as REST_TO_CANONICAL, t as getDeclaredSubcollections } from "./src-DoU9yPqq.js";
+import { n as ANONYMOUS_USER_IDS, r as policy, t as ANONYMOUS_USER_ID } from "./policy-CeA1JcxP.js";
+//#region ../types/src/types/entities.ts
+/**
+* Class used to create a reference to a entity in a different path
+*/
+var EntityRelation = class {
+	__type = "relation";
+	/**
+	* ID of the entity
+	*/
+	id;
+	/**
+	* A string representing the path of the referenced document (relative
+	* to the root of the database).
+	*/
+	path;
+	/**
+	* Pre-fetched data payload to eliminate N+1 queries.
+	* When present, clients can use this directly instead of fetching.
+	*/
+	data;
+	constructor(id, path, data) {
+		this.id = id;
+		this.path = path;
+		this.data = data;
+	}
+	get pathWithId() {
+		return `${this.path}/${this.id}`;
+	}
+	isEntityReference() {
+		return false;
+	}
+	isEntityRelation() {
+		return true;
+	}
+};
+var Vector = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+//#endregion
+//#region ../types/src/types/relations.ts
+/** @group Models */
+function hasForeignKeyOnTarget(relation) {
+	return relation.kind === "hasOne" || relation.kind === "hasMany";
+}
+/** @group Models */
+function isManyToMany(relation) {
+	return relation.kind === "manyToMany";
+}
+//#endregion
 //#region ../common/src/util/common.ts
 var DEFAULT_ONE_OF_TYPE = "type";
 var DEFAULT_ONE_OF_VALUE = "value";
@@ -1014,16 +1067,12 @@ function removeFunctions(o) {
 	if (o === void 0) return void 0;
 	if (o === null) return null;
 	if (typeof o === "object") {
-		if (Array.isArray(o)) return o.map((v) => removeFunctions(v));
+		if (Array.isArray(o)) return o.filter((v) => typeof v !== "function").map((v) => removeFunctions(v));
 		if (!isPlainObject(o)) return o;
-		return Object.entries(o).filter(([_, value]) => typeof value !== "function").map(([key, value]) => {
-			if (Array.isArray(value)) return { [key]: value.map((v) => removeFunctions(v)) };
-			else if (typeof value === "object") return { [key]: removeFunctions(value) };
-			else return { [key]: value };
-		}).reduce((a, b) => ({
-			...a,
-			...b
-		}), {});
+		return Object.entries(o).filter(([_, value]) => typeof value !== "function").reduce((acc, [key, value]) => {
+			acc[key] = removeFunctions(value);
+			return acc;
+		}, {});
 	}
 	return o;
 }
@@ -1162,11 +1211,101 @@ function getPolicyNamesForRule(rule, tableName) {
 	return ops.map((op, opIdx) => rule.name ? ops.length > 1 ? `${rule.name}_${op}` : rule.name : `${tableName}_${op}_${ruleHash}${ops.length > 1 ? `_${opIdx}` : ""}`);
 }
 //#endregion
+//#region ../utils/src/plurals.ts
+/**
+* Returns the singular of an English word.
+*
+* @param {string} word
+* @param {number} [amount]
+* @returns {string}
+*/
+function singular(word, amount) {
+	if (amount !== void 0 && amount !== 1) return word;
+	const singulars = {
+		"(quiz)zes$": "$1",
+		"(matr)ices$": "$1ix",
+		"(vert|ind)ices$": "$1ex",
+		"^(ox)en$": "$1",
+		"(alias)es$": "$1",
+		"(octop|vir)i$": "$1us",
+		"(cris|ax|test)es$": "$1is",
+		"(shoe)s$": "$1",
+		"(o)es$": "$1",
+		"(bus)es$": "$1",
+		"([m|l])ice$": "$1ouse",
+		"(x|ch|ss|sh)es$": "$1",
+		"(m)ovies$": "$1ovie",
+		"(s)eries$": "$1eries",
+		"([^aeiouy]|qu)ies$": "$1y",
+		"([lr])ves$": "$1f",
+		"(tive)s$": "$1",
+		"(hive)s$": "$1",
+		"(li|wi|kni)ves$": "$1fe",
+		"(shea|loa|lea|thie)ves$": "$1f",
+		"(^analy)ses$": "$1sis",
+		"((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$": "$1$2sis",
+		"([ti])a$": "$1um",
+		"(n)ews$": "$1ews",
+		"(h|bl)ouses$": "$1ouse",
+		"(corpse)s$": "$1",
+		"(us)es$": "$1",
+		s$: ""
+	};
+	const irregular = {
+		move: "moves",
+		foot: "feet",
+		goose: "geese",
+		sex: "sexes",
+		child: "children",
+		man: "men",
+		tooth: "teeth",
+		person: "people"
+	};
+	if ([
+		"sheep",
+		"fish",
+		"deer",
+		"moose",
+		"series",
+		"species",
+		"money",
+		"rice",
+		"information",
+		"equipment",
+		"bison",
+		"cod",
+		"offspring",
+		"pike",
+		"salmon",
+		"shrimp",
+		"swine",
+		"trout",
+		"aircraft",
+		"hovercraft",
+		"spacecraft",
+		"sugar",
+		"tuna",
+		"you",
+		"wood"
+	].indexOf(word.toLowerCase()) >= 0) return word;
+	for (const w in irregular) {
+		const pattern = new RegExp(`${irregular[w]}$`, "i");
+		if (pattern.test(word)) return word.replace(pattern, w);
+	}
+	for (const reg in singulars) {
+		const pattern = new RegExp(reg, "i");
+		if (pattern.test(word)) return word.replace(pattern, singulars[reg]);
+	}
+	return word;
+}
+//#endregion
 //#region ../utils/src/names.ts
 /**
 * Generates a foreign key column name from a given string, typically a collection slug or name.
-* It converts the name to snake_case, attempts to singularize it by removing a trailing 's'
-* (a common convention for collection names), and appends '_id'.
+* It singularizes the name, converts it to snake_case and appends '_id'.
+*
+* Singularization runs *before* snake-casing so that acronyms survive: `toSnakeCase`
+* splits on every capital, which turned "URLs" into "ur_ls" and then "ur_l_id".
 *
 * @param name The base name to convert to a foreign key.
 * @returns A foreign key name in the format 'singular_name_id'.
@@ -1176,8 +1315,8 @@ function getPolicyNamesForRule(rule, tableName) {
 * generateForeignKeyName("users")
 *
 * @example
-* // returns "post_id"
-* generateForeignKeyName("posts")
+* // returns "category_id"
+* generateForeignKeyName("categories")
 *
 * @example
 * // returns "product_id"
@@ -1185,8 +1324,41 @@ function getPolicyNamesForRule(rule, tableName) {
 *
 */
 function generateForeignKeyName(name) {
-	const snakeCaseName = toSnakeCase(name);
-	return `${snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName}_id`;
+	return `${toSnakeCase(singularizeForKey(name))}_id`;
+}
+/**
+* `singular()` handles real English plurals, but its final catch-all rule strips
+* any trailing "s", which mangles words that only look plural. Guard the two
+* cases that produce a column name nobody would recognise:
+*
+* - a double "s" ending is never a plural marker ("address", "class", "process"),
+*   so stripping it yields "addres";
+* - a name that singularizes to nothing (the literal "s") would yield "_id".
+*/
+function singularizeForKey(name) {
+	if (/ss$/i.test(name)) return name;
+	const result = singular(name);
+	return result.length > 0 ? result : name;
+}
+/**
+* What `generateForeignKeyName` returned before it learned to singularize:
+* snake-case the name, then chop one trailing "s".
+*
+* This is here to be *detected*, never to be generated. A database provisioned
+* under the old rule carries `categorie_id`, `addresse_id`, `children_id` or
+* `ur_l_id` where the current rule expects `category_id`, `address_id`,
+* `child_id` and `url_id` — and the boot-time schema ensure is additive, so it
+* would create the new column empty beside the populated old one and leave the
+* relation reading nothing. No error, no missing table: the failure is silent,
+* which is the only reason this function still exists.
+*
+* `ensureCollectionSchema` calls it to recognise that shape and say so.
+* Returns the same string as `generateForeignKeyName` for every regular plural,
+* so a caller can compare the two and act only when they differ.
+*/
+function legacyForeignKeyName(name) {
+	const snake = toSnakeCase(name);
+	return `${snake.endsWith("s") ? snake.slice(0, -1) : snake}_id`;
 }
 //#endregion
 //#region ../common/src/util/entities.ts
@@ -1264,7 +1436,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) {
@@ -1426,8 +1598,7 @@ function enumToObjectEntries(enumValues) {
 function resolveRelation(relation, sourceCollection, propertyKey) {
 	const target = relation.target;
 	if (typeof target !== "function") throw new Error(`Relation${relation.relationName ? ` '${relation.relationName}'` : ""} on '${sourceCollection.slug}' has no \`target\`. Give it a thunk: \`target: () => otherCollection\`.`);
-	const targetCollection = target();
-	if (!targetCollection?.slug) throw new Error(`Relation${relation.relationName ? ` '${relation.relationName}'` : ""} on '${sourceCollection.slug}' has a \`target\` that did not resolve to a collection.`);
+	const targetCollection = callTarget(relation, sourceCollection, propertyKey, target);
 	const relationName = relation.relationName ?? propertyKey ?? toSnakeCase(targetCollection.slug);
 	const shared = {
 		relationName,
@@ -1454,7 +1625,8 @@ function resolveRelation(relation, sourceCollection, propertyKey) {
 			cardinality: "one",
 			writable: true,
 			shared: false,
-			foreignKeyOnTarget: relation.foreignKeyOnTarget ?? generateForeignKeyName(sourceName)
+			foreignKeyOnTarget: relation.foreignKeyOnTarget ?? generateForeignKeyName(sourceName),
+			sourceKey: relation.sourceKey
 		};
 		case "hasMany": return {
 			...shared,
@@ -1462,7 +1634,8 @@ function resolveRelation(relation, sourceCollection, propertyKey) {
 			cardinality: "many",
 			writable: true,
 			shared: false,
-			foreignKeyOnTarget: relation.foreignKeyOnTarget ?? generateForeignKeyName(sourceName)
+			foreignKeyOnTarget: relation.foreignKeyOnTarget ?? generateForeignKeyName(sourceName),
+			sourceKey: relation.sourceKey
 		};
 		case "manyToMany": {
 			const sourceTable = getTableName(sourceCollection);
@@ -1491,6 +1664,43 @@ function resolveRelation(relation, sourceCollection, propertyKey) {
 		default: throw new Error(`Unknown relation kind: ${JSON.stringify(relation)}`);
 	}
 }
+/** How this relation is addressed in an error message, before it has a resolved name. */
+function describe(relation, sourceCollection, propertyKey) {
+	const name = relation.relationName ?? propertyKey;
+	return `Relation${name ? ` '${name}'` : ""} on '${sourceCollection.slug}'`;
+}
+/**
+* Call the `target` thunk, and translate the two ways an import cycle breaks it
+* into an error that names the cause.
+*
+* The thunk exists to defer the reference until every module has finished
+* evaluating, and for a cycle that closes at import time it does. What it cannot
+* defer is a cycle that leaves the binding permanently unusable, and there are
+* two shapes of that:
+*
+*  - **ESM/TDZ.** `const` and `class` bindings in a not-yet-evaluated module are
+*    in the temporal dead zone, so reading one throws `ReferenceError: x is not
+*    defined`. The stack points at the thunk — a one-line arrow function that is
+*    obviously fine — and says nothing about the cycle that made it throw.
+*  - **CJS interop.** The half-initialised module object has no `default` yet,
+*    the import resolves to `undefined`, and the thunk returns it without
+*    complaint. That one used to surface here as "did not resolve to a
+*    collection", which is true and unhelpful.
+*
+* Both mean the same thing, and the fix for both is the same: break the cycle,
+* or move the relation into the collection that does not close it.
+*/
+function callTarget(relation, sourceCollection, propertyKey, target) {
+	let targetCollection;
+	try {
+		targetCollection = target();
+	} catch (error) {
+		if (error instanceof ReferenceError) throw new Error(`${describe(relation, sourceCollection, propertyKey)} targets a collection that is not initialized yet — almost always an import cycle between the two collection files. Break the cycle (move the shared piece into a third module, or import the target lazily) so the target's module finishes evaluating before the registry is built.`, { cause: error });
+		throw error;
+	}
+	if (!targetCollection?.slug) throw new Error(`${describe(relation, sourceCollection, propertyKey)} has a \`target\` that resolved to ${targetCollection === void 0 ? "`undefined`" : "something that is not a collection"}. ` + (targetCollection === void 0 ? "Under CommonJS interop an import cycle resolves the default import to `undefined`, so check whether this collection and its target import each other. Otherwise the thunk is returning the wrong value — it must return the collection itself, not a promise or a module." : "The thunk must return a collection config with a `slug`."));
+	return targetCollection;
+}
 //#endregion
 //#region ../common/src/util/relations.ts
 /**
@@ -1527,7 +1737,7 @@ var _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
 function resolveCollectionRelations(collection) {
 	const cached = _resolvedRelationsCache.get(collection);
 	if (cached) return cached;
-	if (!getDataSourceCapabilities(collection.engine).supportsRelations) return {};
+	if (!isRelationalCollectionConfig(collection)) return {};
 	const relations = {};
 	for (const relation of collection.relations ?? []) {
 		const resolved = resolveRelation(relation, collection);
@@ -1543,7 +1753,7 @@ function resolveCollectionRelations(collection) {
 	return relations;
 }
 function getTableName(collection) {
-	if (getDataSourceCapabilities(collection.engine).supportsRelations) return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+	if (isRelationalCollectionConfig(collection)) return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 	return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 }
 function getTableVarName(tableName) {
@@ -1811,7 +2021,12 @@ var UID_NOT_NULL = /auth\.uid\(\)\s+IS\s+NOT\s+NULL/i;
 * is how the trusted *server* context is recognised), so:
 *
 *  - `auth.uid() IS NOT NULL` is a tautology on the user path, and
-*  - `auth.uid() != 'anon'` compares against a string no caller ever has.
+*  - `auth.uid() != 'anon'` excludes one spelling of anonymous and admits the
+*    other. This one is not hypothetical and was not only a foreign habit:
+*    rebase's own request path reported `'anon'` while everything that compiled
+*    or checked a policy used `'anonymous'`, so whichever literal an author
+*    picked, half the anonymous callers walked through. See
+*    {@link ANONYMOUS_USER_IDS}.
 *
 * Either one turns a lockdown into a full grant, and neither looks wrong. No
 * real user id is ever one of these literals, and a user-context request is
@@ -1849,7 +2064,7 @@ function findAnonymousGrants(expr) {
 				found.push({
 					pattern: "foreign-uid-literal",
 					detail: literal.value,
-					explanation: `'${literal.value}' is a ${platform} convention. Rebase reports an anonymous request as '${ANONYMOUS_USER_ID}', so comparing against '${literal.value}' passes for every caller. Use \`condition: policy.authenticated()\` to mean "signed in".`
+					explanation: `'${literal.value}' is a ${platform} convention. Rebase reports an anonymous request as '${ANONYMOUS_USER_ID}', so comparing against '${literal.value}' passes for every caller. Use \`condition: policy.authenticated()\` to mean "signed in" — it compiles to NOT IN (${ANONYMOUS_USER_IDS.map((v) => `'${v}'`).join(", ")}), covering every spelling rebase has reported rather than whichever one you remember.`
 				});
 				return;
 			}
@@ -1944,7 +2159,7 @@ function compile(expr, scope) {
 		}
 		case "rolesOverlap": return `string_to_array(auth.roles(), ',') && ${rolesArraySql(expr.roles)}`;
 		case "rolesContain": return `string_to_array(auth.roles(), ',') @> ${rolesArraySql(expr.roles)}`;
-		case "authenticated": return `auth.uid() IS NOT NULL AND auth.uid() <> ${quoteLiteral(ANONYMOUS_USER_ID)}`;
+		case "authenticated": return `auth.uid() IS NOT NULL AND auth.uid() NOT IN (${ANONYMOUS_USER_IDS.map(quoteLiteral).join(", ")})`;
 		case "serverContext": return "auth.uid() IS NULL";
 		case "existsIn": return compileExistsIn(expr, scope);
 		case "raw": return expr.sql.replace(/\{(\w+)\}/g, (_, col) => `${outerQualifier(scope)}${resolveColumnName(col, scope.outerCollection)}`);
@@ -2016,75 +2231,6 @@ function rolesArraySql(roles) {
 	return `ARRAY[${[...roles].sort().map((r) => `'${r}'`).join(",")}]`;
 }
 //#endregion
-//#region ../common/src/util/callbacks.ts
-/**
-* Helper function to recursively check if there are any callbacks in the properties.
-*/
-function hasPropertyCallbacks(properties, callbackName) {
-	if (!properties) return false;
-	for (const property of Object.values(properties)) {
-		if (property.callbacks?.[callbackName]) return true;
-		if (property.type === "map" && property.properties) {
-			if (hasPropertyCallbacks(property.properties, callbackName)) return true;
-		} else if (property.type === "array" && property.of) {
-			const ofs = Array.isArray(property.of) ? property.of : [property.of];
-			for (const of of ofs) {
-				if (of.callbacks?.[callbackName]) return true;
-				if (of.type === "map" && of.properties && hasPropertyCallbacks(of.properties, callbackName)) return true;
-			}
-		}
-	}
-	return false;
-}
-/**
-* Recursively process properties to apply field-level hooks.
-*/
-async function processProperties(properties, values, previousValues, propsContext, callbackName) {
-	if (!values || typeof values !== "object") return values;
-	const result = { ...values };
-	for (const [key, property] of Object.entries(properties)) {
-		if (result[key] === void 0) continue;
-		let currentValue = result[key];
-		const previousValue = previousValues?.[key];
-		if (property.type === "array" && Array.isArray(currentValue)) {
-			if (property.of && !Array.isArray(property.of)) currentValue = await Promise.all(currentValue.map(async (item, index) => {
-				const prevItem = Array.isArray(previousValue) ? previousValue[index] : void 0;
-				return (await processProperties({ "_tmp": property.of }, { "_tmp": item }, { "_tmp": prevItem }, propsContext, callbackName))["_tmp"];
-			}));
-		} else if (property.type === "map" && property.properties && typeof currentValue === "object") currentValue = await processProperties(property.properties, currentValue, previousValue ?? {}, propsContext, callbackName);
-		if (property.callbacks?.[callbackName]) {
-			const cbRes = await Promise.resolve(property.callbacks[callbackName]({
-				...propsContext,
-				value: currentValue,
-				previousValue
-			}));
-			if (cbRes !== void 0) currentValue = cbRes;
-		}
-		result[key] = currentValue;
-	}
-	return result;
-}
-/**
-* Helper function to extract field-level PropertyCallbacks from a properties schema
-* and wrap them into an CollectionCallbacks object recursively.
-*/
-var buildPropertyCallbacks = (properties) => {
-	if (!properties) return void 0;
-	const propertyCallbacks = {};
-	if (hasPropertyCallbacks(properties, "afterRead")) propertyCallbacks.afterRead = async (props) => {
-		const row = props.row;
-		const processedValues = await processProperties(properties, row, row, props, "afterRead");
-		return {
-			...props.row,
-			...processedValues
-		};
-	};
-	if (hasPropertyCallbacks(properties, "beforeSave")) propertyCallbacks.beforeSave = async (props) => {
-		return await processProperties(properties, props.values, props.previousValues ?? {}, props, "beforeSave");
-	};
-	return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : void 0;
-};
-//#endregion
 //#region ../common/src/util/auth-default-policies.ts
 /**
 * Default RLS policies injected by the schema generator.
@@ -2152,8 +2298,8 @@ function getIdPropertyName$1(collection) {
 * Collections that opt out via `disableDefaultPolicies` are returned unchanged.
 */
 function getEffectiveSecurityRules(collection) {
-	const explicit = [...(isPostgresCollectionConfig(collection) ? collection.securityRules : void 0) ?? []];
-	if (collection.disableDefaultPolicies) return explicit;
+	const explicit = [...collection.securityRules ?? []];
+	if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) return explicit;
 	const tableName = getTableName(collection);
 	const injected = [];
 	injected.push({
@@ -2324,7 +2470,7 @@ function coversUpdate(rule) {
 * stays locked (RLS is still enabled) until they write policies for it.
 */
 function getJunctionSecurityRules(spec) {
-	if (spec.declaringSides.every((side) => side.collection.disableDefaultPolicies)) return [];
+	if (spec.declaringSides.every((side) => isPostgresCollectionConfig(side.collection) && side.collection.disableDefaultPolicies)) return [];
 	const rules = [];
 	rules.push({
 		name: `${spec.table}_default_admin_read`,
@@ -2659,10 +2805,27 @@ function getJunctionSecurityRules(spec) {
 	});
 })))();
 /**
-* Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
+* How wide a `varchar`/`char` column should be for a given property.
+*
+* One definition, three call sites, because they used to disagree. For the same
+* `columnType: "varchar"` property the DDL generator emitted `VARCHAR(255)`
+* while the Drizzle generator emitted a bare `varchar("col")` — which Postgres
+* reads as *unbounded* — so which of the two you ran decided whether the column
+* had a limit at all. Introspection then dropped the length entirely, so reading
+* an existing `character varying(500)` column back and regenerating it produced
+* a `VARCHAR(255)`: a silent narrowing of a column with data already in it.
+*
+* `validation.max` is the property's own statement about how long the value may
+* be, so it is the only sensible source for the column's width — and it keeps
+* the constraint the database enforces in step with the one the app enforces,
+* rather than inventing a second, different limit underneath it.
 */
+function resolveStringColumnLength(prop) {
+	const max = prop.validation?.max;
+	return typeof max === "number" && Number.isInteger(max) && max > 0 ? max : 255;
+}
 //#endregion
-//#region ../../node_modules/.pnpm/fast-equals@6.0.0/node_modules/fast-equals/dist/es/index.mjs
+//#region ../../node_modules/.pnpm/fast-equals@6.0.2/node_modules/fast-equals/dist/es/index.mjs
 var { getOwnPropertyNames, getOwnPropertySymbols } = Object;
 var { hasOwnProperty } = Object.prototype;
 /**
@@ -2698,7 +2861,8 @@ function createIsCircular(areItemsEqual) {
 * not enumerable and symbol properties.
 */
 function getStrictProperties(object) {
-	return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+	const symbols = getOwnPropertySymbols(object);
+	return symbols.length ? getOwnPropertyNames(object).concat(symbols) : getOwnPropertyNames(object);
 }
 /**
 * Whether the object contains the property passed as an own property.
@@ -2771,7 +2935,7 @@ function areMapsEqual(a, b, state) {
 	const size = a.size;
 	if (size !== b.size) return false;
 	if (!size) return true;
-	const matchedIndices = new Array(size);
+	const matchedIndices = new Uint8Array(size);
 	const aIterable = a.entries();
 	let aResult;
 	let bResult;
@@ -2779,7 +2943,7 @@ function areMapsEqual(a, b, state) {
 	while (aResult = aIterable.next()) {
 		if (aResult.done) break;
 		const bIterable = b.entries();
-		let hasMatch = false;
+		let hasMatch = 0;
 		let matchIndex = 0;
 		while (bResult = bIterable.next()) {
 			if (bResult.done) break;
@@ -2790,7 +2954,7 @@ function areMapsEqual(a, b, state) {
 			const aEntry = aResult.value;
 			const bEntry = bResult.value;
 			if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
-				hasMatch = matchedIndices[matchIndex] = true;
+				hasMatch = matchedIndices[matchIndex] = 1;
 				break;
 			}
 			matchIndex++;
@@ -2848,19 +3012,19 @@ function areSetsEqual(a, b, state) {
 	const size = a.size;
 	if (size !== b.size) return false;
 	if (!size) return true;
-	const matchedIndices = new Array(size);
+	const matchedIndices = new Uint8Array(size);
 	const aIterable = a.values();
 	let aResult;
 	let bResult;
 	while (aResult = aIterable.next()) {
 		if (aResult.done) break;
 		const bIterable = b.values();
-		let hasMatch = false;
+		let hasMatch = 0;
 		let matchIndex = 0;
 		while (bResult = bIterable.next()) {
 			if (bResult.done) break;
 			if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
-				hasMatch = matchedIndices[matchIndex] = true;
+				hasMatch = matchedIndices[matchIndex] = 1;
 				break;
 			}
 			matchIndex++;
@@ -2873,8 +3037,8 @@ function areSetsEqual(a, b, state) {
 * Whether the TypedArray instances are equal in value.
 */
 function areTypedArraysEqual(a, b) {
-	let index = a.byteLength;
-	if (b.byteLength !== index || a.byteOffset !== b.byteOffset) return false;
+	let index = a.length;
+	if (b.length !== index || a.byteOffset !== b.byteOffset) return false;
 	while (index-- > 0) if (a[index] !== b[index]) return false;
 	return true;
 }
@@ -3444,6 +3608,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 +3887,42 @@ function rowToEntity(row, slug, primaryKeys = []) {
 		values: row
 	};
 }
+/**
+* The relation envelope `toFlatRow` 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 +3930,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 +3966,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 +4013,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 +4024,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 +4037,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 +4172,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 +4181,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 +4238,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,79 +4255,17 @@ 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));
 }
 //#endregion
-//#region ../common/src/table-classification.ts
-/** Schemas that are always considered Rebase-internal. */
-var REBASE_INTERNAL_SCHEMAS = ["rebase", "auth"];
-/** Table-name prefixes that mark a table as Rebase-internal regardless of schema. */
-var REBASE_INTERNAL_PREFIXES = [
-	"_rebase_",
-	"_auth_",
-	"drizzle_"
-];
-/**
-* Synchronously classify a table based on naming conventions.
-*
-* @param tableName  - The unqualified name of the table.
-* @param schemaName - The schema the table belongs to (e.g. `"public"`, `"rebase"`).
-* @returns `"rebase-internal"` when the table belongs to a reserved schema or
-*          carries a reserved prefix; `"user"` otherwise.
-*
-* @remarks
-* Junction-table detection requires an async database query and is therefore
-* **not** handled by this function. Use {@link detectJunctionTables} to obtain
-* the set of junction tables, then reclassify as needed.
-*/
-function classifyTable(tableName, schemaName) {
-	if (REBASE_INTERNAL_SCHEMAS.includes(schemaName) || REBASE_INTERNAL_PREFIXES.some((prefix) => tableName.startsWith(prefix))) return "rebase-internal";
-	return "user";
-}
-/** SQL query that detects junction tables in the `public` schema. */
-var JUNCTION_TABLES_SQL = `
-  SELECT t.table_name
-  FROM information_schema.tables t
-  WHERE t.table_schema = 'public'
-    AND t.table_type = 'BASE TABLE'
-    AND NOT EXISTS (
-      SELECT 1
-      FROM information_schema.columns c
-      WHERE c.table_schema = t.table_schema
-        AND c.table_name = t.table_name
-        AND c.column_name NOT IN (
-          SELECT kcu.column_name
-          FROM information_schema.key_column_usage kcu
-          JOIN information_schema.table_constraints tc
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          WHERE tc.constraint_type = 'FOREIGN KEY'
-            AND kcu.table_schema = t.table_schema
-            AND kcu.table_name = t.table_name
-        )
-    )
-`;
-/**
-* Asynchronously detect junction (link) tables in the `public` schema.
-*
-* A junction table is defined as a table where **every** column participates in
-* at least one foreign-key constraint.
-*
-* @param executeSql - A callback that executes a raw SQL string and returns the
-*                     resulting rows.
-* @returns A `Set` containing the names of all detected junction tables.
-*/
-async function detectJunctionTables(executeSql) {
-	const rows = await executeSql(JUNCTION_TABLES_SQL);
-	const junctionTables = /* @__PURE__ */ new Set();
-	for (const row of rows) if (typeof row.table_name === "string") junctionTables.add(row.table_name);
-	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 { DEFAULT_ONE_OF_TYPE as A, updateDateAutoValues as C, mergeDeep as D, getPolicyNamesForRule as E, hasForeignKeyOnTarget as M, isManyToMany as N, camelCase as O, Vector as P, normalizeToEntityRelation as S, legacyForeignKeyName as T, buildCompositeId as _, getJunctionSecurityRules as a, createRelationRef as b, policyToPostgres as c, findRelation as d, getColumnName as f, resolveCollectionRelations as g, getTableVarName as h, getJunctionCollectionConfig as i, DEFAULT_ONE_OF_VALUE as j, toSnakeCase as k, securityRuleToConditions as l, getTableName as m, CollectionRegistry as n, resolveJunctionSpecs as o, getEnumVarName as p, resolveStringColumnLength as r, getEffectiveSecurityRules as s, buildSdkData as t, findAnonymousGrants as u, getDeclaredPrimaryKeys as v, generateForeignKeyName as w, createRelationRefWithData as x, parseIdValues as y };
 
-//# sourceMappingURL=src-3VmUJ8Xn.js.map
+//# sourceMappingURL=src-CzbghKwf.js.map