@rebasepro/common 0.11.1-canary.gfd39654 → 0.12.0

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { ANONYMOUS_USER_ID, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, isManyToMany, isPostgresCollectionConfig, policy, toCanonicalOp } from "@rebasepro/types";
-import { deepClone, generateForeignKeyName, getIn, getPolicyOperations, isDefaultFieldConfigId, mergeDeep, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
+import { ANONYMOUS_USER_ID, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, isManyToMany, isPostgresCollectionConfig, isRelationalCollectionConfig, policy, toCanonicalOp } from "@rebasepro/types";
+import { deepClone, generateForeignKeyName, getIn, getPolicyOperations, isDefaultFieldConfigId, mergeDeep, prettifyIdentifier, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
 //#region src/util/common.ts
@@ -142,7 +142,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) {
@@ -494,7 +494,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);
@@ -510,7 +510,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) {
@@ -1606,8 +1606,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({
@@ -1649,8 +1649,8 @@ function getEffectiveSecurityRules(collection) {
 * DDL, which policies are injected and how to take them off.
 */
 function getInjectedSecurityRules(collection) {
-	if (collection.disableDefaultPolicies) return [];
-	const explicitCount = ((isPostgresCollectionConfig(collection) ? collection.securityRules : void 0) ?? []).length;
+	if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) return [];
+	const explicitCount = (collection.securityRules ?? []).length;
 	return getEffectiveSecurityRules(collection).slice(explicitCount);
 }
 //#endregion
@@ -1794,7 +1794,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`,
@@ -1947,6 +1947,243 @@ function buildConditionContext(params) {
 * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
 */
 //#endregion
+//#region src/util/pg-column-to-property.ts
+/**
+* Maps a PostgreSQL column data type to a Rebase property type.
+*/
+function pgTypeToRebaseProperty(column) {
+	const { column_name, data_type, udt_name, is_nullable, column_default, enum_values } = column;
+	const required = is_nullable === "NO";
+	const prettifiedName = prettifyIdentifier(column_name);
+	const isAutoId = column_default != null && (column_default.includes("nextval") || column_default.includes("gen_random_uuid") || column_default.includes("uuid_generate") || column_default.includes("identity"));
+	if (data_type === "USER-DEFINED" && enum_values && enum_values.length > 0) return {
+		type: "string",
+		name: prettifiedName,
+		enum: enum_values.map((v) => ({
+			id: v,
+			label: prettifyIdentifier(v)
+		})),
+		validation: required ? { required: true } : void 0
+	};
+	const dt = data_type.toLowerCase();
+	switch (dt) {
+		case "character varying":
+		case "varchar":
+		case "text":
+		case "char":
+		case "character":
+		case "citext": {
+			let colType = "varchar";
+			if (dt === "text" || dt === "citext") colType = "text";
+			if (dt === "char" || dt === "character") colType = "char";
+			const prop = {
+				type: "string",
+				name: prettifiedName,
+				columnType: colType,
+				validation: required ? { required: true } : void 0
+			};
+			if (isAutoId) prop.isId = "manual";
+			return prop;
+		}
+		case "uuid": {
+			const prop = {
+				type: "string",
+				name: prettifiedName,
+				validation: required ? { required: true } : void 0
+			};
+			if (isAutoId) prop.isId = "uuid";
+			return prop;
+		}
+		case "integer":
+		case "bigint":
+		case "smallint": {
+			const prop = {
+				type: "number",
+				name: prettifiedName,
+				columnType: dt === "bigint" ? "bigint" : "integer",
+				validation: {
+					...required ? { required: true } : {},
+					integer: true
+				}
+			};
+			if (isAutoId) prop.isId = "increment";
+			return prop;
+		}
+		case "serial":
+		case "bigserial":
+		case "smallserial": return {
+			type: "number",
+			name: prettifiedName,
+			columnType: dt === "bigserial" ? "bigserial" : "serial",
+			isId: "increment",
+			validation: {
+				...required ? { required: true } : {},
+				integer: true
+			}
+		};
+		case "numeric":
+		case "decimal":
+		case "real":
+		case "double precision": {
+			let colType = "numeric";
+			if (dt === "real") colType = "real";
+			if (dt === "double precision") colType = "double precision";
+			return {
+				type: "number",
+				name: prettifiedName,
+				columnType: colType,
+				validation: required ? { required: true } : void 0
+			};
+		}
+		case "boolean": return {
+			type: "boolean",
+			name: prettifiedName,
+			validation: required ? { required: true } : void 0
+		};
+		case "timestamp with time zone":
+		case "timestamp without time zone":
+		case "timestamp":
+		case "timestamptz":
+		case "date":
+		case "time with time zone":
+		case "time without time zone":
+		case "time": {
+			let colType = "timestamp";
+			if (dt.startsWith("date")) colType = "date";
+			if (dt.startsWith("time ") || dt === "time") colType = "time";
+			return {
+				type: "date",
+				name: prettifiedName,
+				columnType: colType,
+				validation: required ? { required: true } : void 0
+			};
+		}
+		case "jsonb":
+		case "json": return {
+			type: "map",
+			name: prettifiedName,
+			columnType: dt === "jsonb" ? "jsonb" : "json",
+			keyValue: true,
+			properties: {}
+		};
+		case "array":
+		case "ARRAY": {
+			let innerType = "string";
+			let colType = void 0;
+			if (udt_name === "_text" || udt_name === "_varchar") {
+				innerType = "string";
+				colType = "text[]";
+			} else if (udt_name === "_int4" || udt_name === "_int2" || udt_name === "_int8") {
+				innerType = "number";
+				colType = "integer[]";
+			} else if (udt_name === "_bool") {
+				innerType = "boolean";
+				colType = "boolean[]";
+			} else if (udt_name === "_numeric") {
+				innerType = "number";
+				colType = "numeric[]";
+			}
+			return {
+				type: "array",
+				name: prettifiedName,
+				columnType: colType,
+				of: { type: innerType }
+			};
+		}
+		default: return {
+			type: "string",
+			name: prettifiedName,
+			validation: required ? { required: true } : void 0
+		};
+	}
+}
+/**
+* Builds a collection description from PostgreSQL table metadata.
+* This is used when creating a new collection from an existing database table.
+*/
+function buildCollectionFromTableMetadata(tableName, metadata) {
+	const properties = {};
+	const propertiesOrder = [];
+	const relations = [];
+	const securityRules = [];
+	for (const column of metadata.columns) {
+		const property = pgTypeToRebaseProperty(column);
+		if (property) {
+			const propRecord = property;
+			Object.keys(propRecord).forEach((key) => propRecord[key] === void 0 && delete propRecord[key]);
+			properties[column.column_name] = property;
+			propertiesOrder.push(column.column_name);
+		}
+	}
+	if (metadata.foreignKeys) for (const fk of metadata.foreignKeys) {
+		const relName = fk.column_name.endsWith("_id") ? fk.column_name.substring(0, fk.column_name.length - 3) : fk.column_name;
+		relations.push({
+			id: fk.column_name,
+			relationName: relName,
+			target: fk.foreign_table_name,
+			kind: "belongsTo",
+			localKey: fk.column_name
+		});
+	}
+	if (metadata.junctions) for (const junction of metadata.junctions) {
+		const relName = junction.target_table_name;
+		relations.push({
+			id: junction.target_table_name + "_relation",
+			relationName: relName,
+			target: junction.target_table_name,
+			kind: "manyToMany",
+			through: {
+				table: junction.junction_table_name,
+				sourceColumn: junction.source_column_name,
+				targetColumn: junction.target_column_name
+			}
+		});
+	}
+	if (metadata.policies) for (const policy of metadata.policies) {
+		let operations = [];
+		switch (policy.cmd) {
+			case "ALL":
+				operations = ["all"];
+				break;
+			case "SELECT":
+				operations = ["select"];
+				break;
+			case "INSERT":
+				operations = ["insert"];
+				break;
+			case "UPDATE":
+				operations = ["update"];
+				break;
+			case "DELETE":
+				operations = ["delete"];
+				break;
+		}
+		const qual = policy.qual ?? void 0;
+		const withCheck = policy.with_check ?? void 0;
+		if (qual) securityRules.push({
+			name: policy.policy_name,
+			operations,
+			roles: policy.roles ?? [],
+			using: qual,
+			...withCheck ? { withCheck } : {}
+		});
+		else securityRules.push({
+			name: policy.policy_name,
+			operations,
+			roles: policy.roles ?? []
+		});
+	}
+	return {
+		name: prettifyIdentifier(tableName),
+		slug: tableName,
+		table: tableName,
+		properties,
+		propertiesOrder,
+		...relations.length > 0 ? { relations } : {},
+		...securityRules.length > 0 ? { securityRules } : {}
+	};
+}
+//#endregion
 //#region src/data/resolveDataSource.ts
 /**
 * Build a keyed registry from a list of {@link DataSourceDefinition}s.
@@ -2453,6 +2690,163 @@ var QueryBuilder = class {
 	}
 };
 //#endregion
+//#region src/data/paginate.ts
+/**
+* The pagination engine behind `iterate()` / `findAll()`.
+*
+* It lives here, above both transports, on purpose: the HTTP client and the
+* in-process accessor implement the same `SDKCollectionClient` contract, and a
+* helper written twice is a helper that drifts. Both call into this file, so
+* "the SDK paginates like *this*" has exactly one definition.
+*
+* Everything below is expressed in terms of a single `find(params)` function,
+* which is all either transport has to supply.
+*/
+/** Rows requested per page when the caller does not say. */
+var DEFAULT_PAGE_SIZE = 200;
+/** 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;
+}
+/**
+* Build the `iterate` / `findAll` pair for one collection from its `find`.
+*
+* Both transports call this, which is what keeps the two implementations from
+* being two implementations.
+*/
+function createPaginationHelpers(find, label) {
+	return {
+		iterate: (params) => paginateFind(find, params, label),
+		findAll: (params) => collectAllPages(find, params, label)
+	};
+}
+//#endregion
 //#region src/data/filter-dialect.ts
 /**
 * REST wire-format adapter for the unified filter system.
@@ -2755,6 +3149,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) {
@@ -2762,14 +3192,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,
@@ -2798,7 +3228,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
 			});
@@ -2844,6 +3275,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,
@@ -2854,7 +3286,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,
@@ -2867,10 +3299,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,
@@ -3001,7 +3434,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);
@@ -3010,6 +3443,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;
@@ -3051,7 +3490,7 @@ function toSdkCollectionClient(snap) {
 /**
 * Wrap a flat {@link SDKCollectionClient} into a Entity-shaped
 * {@link CollectionAccessor}. Every returned row is re-wrapped into the
-* `{ id, path, values }` view-model the admin CMS renders.
+* `{ id, path, values }` view-model the admin admin renders.
 */
 function toEntityAccessor(sdk, slug, getPks = () => []) {
 	const accessor = {
@@ -3099,10 +3538,10 @@ function toEntityAccessor(sdk, slug, getPks = () => []) {
 /**
 * Wrap a flat {@link RebaseSdkData} into a Entity-shaped {@link RebaseData}.
 *
-* This is the **CMS boundary**: the SDK client (`client.data`) returns flat
+* This is the **admin boundary**: the SDK client (`client.data`) returns flat
 * rows, but the admin renders the `Entity` view-model (`entity.values.*`).
 * `core/Rebase.tsx` wraps `client.data` through this before handing it to the
-* CMS `RebaseDataContext` — without it the admin renders rows with only their
+* admin `RebaseDataContext` — without it the admin renders rows with only their
 * `id`.
 */
 function wrapAsEntityData(sdkData, options) {
@@ -3136,7 +3575,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;
@@ -3153,8 +3592,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));
@@ -3330,6 +3773,6 @@ async function detectJunctionTables(executeSql) {
 	return junctionTables;
 }
 //#endregion
-export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, and, buildCollection, buildCompositeId, buildConditionContext, buildProperty, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, cond, createDataSourceRegistry, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEntityChildViews, getEnumVarName, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isJunctionBackedRelation, isPropertyBuilder, isRebaseInternalTable, normalizeToEntityRelation, or, parseIdValues, policyToPostgres, registerConditionOperations, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolveRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, sanitizeData, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, sqlToPolicy, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
+export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_FIND_ALL_MAX_ROWS, DEFAULT_MAX_PAGES, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, DEFAULT_PAGE_SIZE, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, RebasePaginationError, and, buildCollection, buildCollectionFromTableMetadata, buildCompositeId, buildConditionContext, buildProperty, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, collectAllPages, cond, createDataSourceRegistry, createPaginationHelpers, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEntityChildViews, getEnumVarName, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isJunctionBackedRelation, isPropertyBuilder, isRebaseInternalTable, normalizeToEntityRelation, or, paginateFind, parseIdValues, policyToPostgres, registerConditionOperations, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolveRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, sanitizeData, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, sqlToPolicy, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
 
 //# sourceMappingURL=index.es.js.map