@rebasepro/common 0.24.0 → 0.24.1-canary.g56af4a4

package/dist/data/buildRebaseData.es.js

@@ -0,0 +1,1026 @@
+import { buildCompositeId, resolvePrimaryKeys } from "../util/identity.es.js";
+import { resolveCollectionRelations } from "../util/relations.es.js";
+import { cursorToStartAfter, decodeCursor, reconcileCursorOrder } from "./cursor.es.js";
+import { normalizeOrderBy } from "./sort-dialect.es.js";
+import { mergeIncludeSpecs } from "./include-spec.es.js";
+import { etagOf } from "./row-etag.es.js";
+import { QueryBuilder } from "./query_builder.es.js";
+import { collectAllPages, paginateFind, resolveFindWindow } from "./paginate.es.js";
+import { deserializeFilter } from "./filter-dialect.es.js";
+import { DEFAULT_VECTOR_LIST_LIMIT, EntityRelation, RebaseApiError, RebaseClientError, isUnsupported, sortKeyToString, unsupportedMethod } from "@rebasepro/types";
+import { toSnakeCase, toWireKey } from "@rebasepro/utils";
+//#region src/data/buildRebaseData.ts
+/**
+* What a client says when its data source cannot subscribe.
+*
+* Named rather than inlined so the sentence a caller sees does not depend on
+* which of the two adapters below happened to build the client.
+*/
+var noRealtime = (slug) => `Realtime is not available for "${slug}": its data source does not support subscriptions.`;
+/** What a client says when its data source cannot count. */
+var noCount = (slug) => `Counting is not available for "${slug}": its data source does not support it.`;
+/**
+* Derive the response key an aggregate comes back under.
+*
+* `sum(total)` → `sum_total`, `count()` → `count`. Written once, here, because
+* the REST parser derives the same alias from `?select=sum(total)` and the two
+* have to agree — a caller reading `row.sum_total` off an SDK result and off an
+* HTTP response is reading the same key or the SDK is broken.
+*/
+function aggregateAlias(fn, field) {
+	return field ? `${fn}_${field}` : fn;
+}
+function toDriverAggregate(select) {
+	const field = select.field;
+	return {
+		fn: select.fn,
+		field,
+		alias: aggregateAlias(select.fn, field)
+	};
+}
+/**
+* What a client says when its data source cannot aggregate.
+*
+* A stub rather than a fallback that fetches and reduces in JavaScript: that
+* would be wrong under a `limit` and unaffordable without one, and it would look
+* like it had worked.
+*/
+/** What a client says when its data source cannot read a collection's trash. */
+var noTrash = (slug) => `The trash is not available for "${slug}": its data source cannot read soft-deleted rows.`;
+/** What `softDelete: true` names the field a delete stamps; a restore clears it. */
+var DEFAULT_SOFT_DELETE_FIELD = "deletedAt";
+var noAggregate = (slug) => `Aggregates are not available for "${slug}": its data source does not implement them.`;
+function createPrimaryKeyResolver(options) {
+	const cache = /* @__PURE__ */ new Map();
+	const warned = /* @__PURE__ */ new Set();
+	return function primaryKeysFor(slug) {
+		const cached = cache.get(slug);
+		if (cached) return cached;
+		const collection = options?.resolveCollection?.(slug);
+		if (!collection) return [];
+		const keys = resolvePrimaryKeys(collection);
+		if (keys.length > 0) {
+			cache.set(slug, keys);
+			return keys;
+		}
+		if (!warned.has(slug)) {
+			warned.add(slug);
+			console.warn(`[rebase] Collection '${slug}' declares no primary key, so its rows have no address: detail links, caching and relations will not work for it. Mark the key property with \`isId\` in its collection config — the server logs which column to mark at boot, if its schema knows the key.`);
+		}
+		return keys;
+	};
+}
+/**
+* Build the admin's view model out of the row the wire serves.
+*
+* The wire has ONE shape, for every consumer: flat columns, typed the way the
+* database typed them, and a relation rendered as the target's own columns (or
+* only its foreign key, when nothing asked for it). That is the REST contract,
+* what `find()` returns, what `listen()` pushes, and what the generated types
+* describe.
+*
+* The admin renders neither of those directly. Its date field requires a real
+* `Date` and rejects a string outright; its relation cells read `.data.values`
+* off a relation ref. Those requirements are the *admin's*, so they are met
+* here — in the browser, from the collection config the panel already has —
+* rather than by asking the server for a second wire shape.
+*
+* That second shape is what this replaces. Until 2026-09-09 the realtime wire
+* carried the view model and every other read carried flat rows, so `find()`
+* and `listen()` answered one query two ways; unifying the wire without doing
+* this conversion is what left every date cell reading "Invalid date value"
+* and every relation cell "Unexpected value".
+*
+* Values already in view-model form pass through untouched: a driver that
+* still sends `{ __type: "date" }` or a relation ref (the client revives both)
+* is served by the same walk.
+*/
+function toViewModelValues(values, properties, collection, resolveCollection) {
+	if (!properties) return values;
+	const relations = collection ? resolveCollectionRelations(collection) : {};
+	let out;
+	const write = (key, value) => {
+		out = out ?? { ...values };
+		out[key] = value;
+	};
+	for (const [key, rawProperty] of Object.entries(properties)) {
+		const property = rawProperty;
+		if (!property) continue;
+		if (!(key in values)) {
+			const fkRelation = relations[key];
+			const column = fkRelation && "localKey" in fkRelation ? fkRelation.localKey : void 0;
+			const fk = column !== void 0 ? values[column] ?? values[toWireKey(column)] : void 0;
+			const fkTarget = fkRelation?.targetSlug;
+			if (fkTarget && (typeof fk === "string" || typeof fk === "number")) write(key, new EntityRelation(fk, fkTarget));
+			continue;
+		}
+		const value = values[key];
+		if (value === null || value === void 0) continue;
+		const relation = relations[key];
+		if (relation && (property.type === "relation" || property.of?.type === "relation" || property.type === "array")) {
+			const target = relation.targetSlug;
+			if (!target) continue;
+			const targetProperties = resolveCollection?.(target)?.properties;
+			const targetCollection = resolveCollection?.(target);
+			const toRef = (item) => {
+				if (item instanceof EntityRelation) return item;
+				if (typeof item === "object" && item !== null && "__type" in item) return item;
+				if (typeof item === "object" && item !== null) {
+					const row = item;
+					const keys = targetCollection ? resolvePrimaryKeys(targetCollection) : [];
+					const id = keys.length > 0 ? buildCompositeId(row, keys) : row.id;
+					if (id === void 0 || id === null || id === "") return item;
+					return new EntityRelation(id, target, {
+						id,
+						path: target,
+						values: toViewModelValues(row, targetProperties, targetCollection, resolveCollection)
+					});
+				}
+				if (typeof item === "string" || typeof item === "number") return new EntityRelation(item, target);
+				return item;
+			};
+			write(key, Array.isArray(value) ? value.map(toRef) : toRef(value));
+			continue;
+		}
+		if (property.type === "date" && !(value instanceof Date)) {
+			if (typeof value === "string" || typeof value === "number") {
+				const date = new Date(value);
+				write(key, isNaN(date.getTime()) ? null : date);
+			}
+			continue;
+		}
+		if (property.type === "map" && property.properties && typeof value === "object" && !Array.isArray(value)) write(key, toViewModelValues(value, property.properties, void 0, resolveCollection));
+	}
+	return out ?? values;
+}
+/**
+* Give a flat row the Entity view-model the admin renders.
+*
+* The address is *derived here* — it is not a column, and the row it came from
+* does not contain one. Rows carry exactly what the table has, with the types
+* Postgres returned; the id is this layer's invention, and this is the only
+* place it is minted.
+*
+* `primaryKeys` empty falls back to a literal `id` on the row: drivers other
+* than postgres still serve rows with one, and this keeps them working.
+*/
+function rowToEntity(row, slug, primaryKeys = [], toViewModel) {
+	const { _matches, ...values } = row;
+	const etag = etagOf(row);
+	return {
+		id: primaryKeys.length > 0 ? buildCompositeId(row, primaryKeys) : row.id,
+		path: slug,
+		values: toViewModel ? toViewModel(values) : values,
+		..._matches ? { searchMatches: _matches } : {},
+		...etag ? { etag } : {}
+	};
+}
+/**
+* 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 Postgres now serves it on every read, so
+* against that driver this walk finds nothing to do. It stays for the drivers
+* whose own `fetchCollection` still answers with refs: a developer reading
+* through this accessor gets one shape whichever driver is underneath.
+*
+* Only applied where the REST pipeline is the contract (see `find`); a driver
+* without a `restFetchService` keeps whatever it returns.
+*
+* Note this is NOT how the admin gets its view model — that is built in the
+* browser by {@link toViewModelValues}, from the same flat row.
+*/
+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 = () => [], toViewModel, storedPath = () => slug) {
+	/**
+	* One page of the collection, and its count. `withDeleted: "only"` reads
+	* the trash (see `trash` below) through the same pipeline, so a trashed
+	* page is paged, counted and shaped exactly as a live one.
+	*/
+	async function findRows(params, withDeleted) {
+		const filter = params?.where ? deserializeFilter(params.where) : void 0;
+		const window = resolveFindWindow(params);
+		const { offset, driverOffset } = window;
+		const limit = params?.limit === void 0 && params?.vectorSearch ? DEFAULT_VECTOR_LIST_LIMIT : window.limit;
+		const cursor = params?.after ? decodeCursor(params.after) : void 0;
+		const sort = cursor ? reconcileCursorOrder(cursor, normalizeOrderBy(params?.orderBy)) : normalizeOrderBy(params?.orderBy);
+		const orderBy = sort && sort.length > 0 ? sort : void 0;
+		const startAfter = cursor ? cursorToStartAfter(cursor) : void 0;
+		const seeking = startAfter !== void 0;
+		const counting = driver.count !== void 0 && params?.count !== "none" && params?.distinct !== true && params?.vectorSearch?.threshold === void 0;
+		const probing = seeking || !counting;
+		const probeLimit = probing ? limit + 1 : limit;
+		const read = async (reader) => {
+			const fetchService = reader.restFetchService;
+			return {
+				fetched: fetchService ? await fetchService.fetchCollectionForRest(storedPath(), {
+					filter,
+					logical: params?.logical,
+					limit: probeLimit,
+					offset: seeking ? void 0 : driverOffset,
+					startAfter,
+					orderBy,
+					searchString: params?.searchString,
+					searchExplain: params?.searchExplain,
+					vectorSearch: params?.vectorSearch,
+					fields: params?.fields,
+					distinct: params?.distinct,
+					...withDeleted ? { withDeleted } : {}
+				}, params?.include) : await reader.fetchCollection({
+					path: storedPath(),
+					limit: probeLimit,
+					offset: seeking ? void 0 : driverOffset,
+					startAfter,
+					filter,
+					logical: params?.logical,
+					orderBy,
+					searchString: params?.searchString,
+					searchExplain: params?.searchExplain,
+					vectorSearch: params?.vectorSearch,
+					include: params?.include,
+					fields: params?.fields,
+					distinct: params?.distinct,
+					...withDeleted ? { withDeleted } : {}
+				}),
+				counted: counting && reader.count ? await reader.count({
+					path: storedPath(),
+					filter,
+					logical: params?.logical,
+					searchString: params?.searchString,
+					vectorSearch: params?.vectorSearch,
+					...withDeleted ? { withDeleted } : {}
+				}) : void 0
+			};
+		};
+		const { fetched, counted } = driver.readTogether ? await driver.readTogether(read) : await read(driver);
+		const rows = probing ? fetched.slice(0, limit) : fetched;
+		const total = counted ?? rows.length + offset;
+		const hasMore = probing ? fetched.length > limit : offset + rows.length < total;
+		const last = rows[rows.length - 1];
+		const nextCursor = hasMore && last && driver.restFetchService?.cursorFor ? driver.restFetchService.cursorFor(storedPath(), last, orderBy) : void 0;
+		return {
+			data: rows.map((row) => rowToEntity(row, slug, getPks(), toViewModel)),
+			meta: {
+				total,
+				limit,
+				offset,
+				hasMore,
+				...nextCursor && { nextCursor }
+			}
+		};
+	}
+	async function countRows(params, withDeleted) {
+		if (!driver.count) throw new Error(noCount(slug));
+		const filter = params?.where ? deserializeFilter(params.where) : void 0;
+		return driver.count({
+			path: storedPath(),
+			filter,
+			logical: params?.logical,
+			searchString: params?.searchString,
+			vectorSearch: params?.vectorSearch,
+			...withDeleted ? { withDeleted } : {}
+		});
+	}
+	const accessor = {
+		find(params) {
+			return findRows(params);
+		},
+		async findById(id, options) {
+			const fetchService = driver.restFetchService;
+			const row = fetchService ? await fetchService.fetchOneForRest(storedPath(), id, options?.include) : await driver.fetchOne({
+				path: storedPath(),
+				id
+			});
+			return row ? rowToEntity(row, slug, getPks(), toViewModel) : void 0;
+		},
+		aggregate: driver.restFetchService?.aggregate ? async (params) => {
+			const limit = (params.groupBy?.length ?? 0) > 0 ? params.limit : void 0;
+			const rows = await driver.restFetchService.aggregate(storedPath(), {
+				aggregates: params.select.map(toDriverAggregate),
+				groupBy: params.groupBy,
+				filter: params.where ? deserializeFilter(params.where) : void 0,
+				logical: params.logical,
+				searchString: params.searchString,
+				limit: limit !== void 0 ? limit + 1 : params.limit,
+				offset: params.offset,
+				orderBy: normalizeOrderBy(params.orderBy)
+			});
+			if (limit === void 0) return rows;
+			const page = rows.slice(0, limit);
+			const meta = {
+				limit,
+				offset: params.offset ?? 0,
+				hasMore: rows.length > limit
+			};
+			Object.defineProperty(page, "meta", {
+				value: meta,
+				enumerable: false
+			});
+			return page;
+		} : void 0,
+		async create(data, id) {
+			return rowToEntity(await driver.save({
+				path: storedPath(),
+				values: data,
+				id,
+				status: "new"
+			}), slug, getPks(), toViewModel);
+		},
+		createMany: driver.saveMany ? async (data, options) => {
+			return (await driver.saveMany({
+				path: storedPath(),
+				rows: data,
+				upsert: options?.upsert,
+				onConflict: options?.onConflict
+			})).map((row) => rowToEntity(row, slug, getPks(), toViewModel));
+		} : void 0,
+		async update(id, data) {
+			return rowToEntity(await driver.save({
+				path: storedPath(),
+				values: data,
+				id,
+				status: "existing"
+			}), slug, getPks(), toViewModel);
+		},
+		async delete(id) {
+			return driver.delete({ row: {
+				id,
+				path: storedPath()
+			} });
+		},
+		updateMany: driver.updateMany ? async (updates) => {
+			return (await driver.updateMany({
+				path: storedPath(),
+				updates: updates.map((u) => ({
+					id: u.id,
+					values: u.data
+				}))
+			})).map((row) => rowToEntity(row, slug, getPks(), toViewModel));
+		} : void 0,
+		deleteMany: driver.deleteMany ? async (ids) => {
+			await driver.deleteMany({
+				path: storedPath(),
+				ids
+			});
+		} : void 0,
+		count: driver.count ? (params) => countRows(params) : void 0,
+		trash: {
+			find: (params) => findRows(params, "only"),
+			count: (params) => countRows(params, "only"),
+			purge: (id) => driver.delete({
+				row: {
+					id,
+					path: storedPath()
+				},
+				hard: true
+			}),
+			purgeMany: driver.deleteMany ? async (ids) => {
+				await driver.deleteMany({
+					path: storedPath(),
+					ids,
+					hard: true
+				});
+			} : void 0
+		},
+		listen: driver.listenCollection ? (params, onUpdate, onError) => {
+			const { limit, offset, driverOffset } = resolveFindWindow(params);
+			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
+			return driver.listenCollection({
+				path: storedPath(),
+				limit,
+				offset: driverOffset,
+				filter: params?.where,
+				logical: params?.logical,
+				orderBy: normalizeOrderBy(params?.orderBy),
+				searchString: params?.searchString,
+				searchExplain: params?.searchExplain,
+				vectorSearch: params?.vectorSearch,
+				onUpdate: (entities) => {
+					onUpdate({
+						data: entities.map((row) => rowToEntity(normalize(row), slug, getPks(), toViewModel)),
+						meta: {
+							total: offset + entities.length,
+							limit,
+							offset,
+							hasMore: entities.length >= limit
+						}
+					});
+				},
+				onError
+			});
+		} : void 0,
+		listenById: driver.listenOne ? (id, onUpdate, onError, options) => {
+			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
+			return driver.listenOne({
+				path: storedPath(),
+				id,
+				include: options?.include,
+				onUpdate: (entity) => onUpdate(entity ? rowToEntity(normalize(entity), slug, getPks(), toViewModel) : void 0),
+				onError
+			});
+		} : void 0,
+		where(columnOrCondition, operator, value) {
+			const builder = new QueryBuilder(accessor);
+			if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+			return builder.where(columnOrCondition, operator, value);
+		},
+		orderBy(column, ascending) {
+			return new QueryBuilder(accessor).orderBy(column, ascending);
+		},
+		limit(count) {
+			return new QueryBuilder(accessor).limit(count);
+		},
+		offset(count) {
+			return new QueryBuilder(accessor).offset(count);
+		},
+		search(searchString, options) {
+			return new QueryBuilder(accessor).search(searchString, options);
+		},
+		vectorSearch(property, vector, options) {
+			return new QueryBuilder(accessor).vectorSearch(property, vector, options);
+		},
+		include(...relations) {
+			return new QueryBuilder(accessor).include(...relations);
+		}
+	};
+	return accessor;
+}
+/**
+* Build a `RebaseData` object from a `DataDriver` using JavaScript Proxy.
+*
+* This is the key bridge: any property access like `data.products` returns
+* a `CollectionAccessor` backed by the underlying DataDriver, without
+* needing per-collection code generation.
+*
+* @example
+* const data = buildRebaseData(driver);
+* await data.products.create({ name: "Camera", price: 299 });
+* const { data: items } = await data.products.find({ where: { status: ["==", "published"] } });
+*/
+/**
+* The view-model converter for one collection, or `undefined` when there is no
+* collection config to build it from.
+*
+* Absent is the honest answer for every consumer that is not the admin: the
+* flat SDK derives itself from this same layer (`buildSdkData`) and must keep
+* the wire's own types, and it registers no collection resolver.
+*/
+function createViewModelConverter(options) {
+	if (!options?.resolveCollection) return () => void 0;
+	return function converterFor(slug) {
+		return (values) => {
+			const collection = options.resolveCollection?.(slug);
+			if (!collection) return values;
+			return toViewModelValues(values, collection.properties, collection, options.resolveCollection);
+		};
+	};
+}
+function buildRebaseData(driver, options) {
+	const cache = /* @__PURE__ */ new Map();
+	const primaryKeysFor = createPrimaryKeyResolver(options);
+	const viewModelFor = createViewModelConverter(options);
+	function getAccessor(slug) {
+		let accessor = cache.get(slug);
+		if (!accessor) {
+			accessor = createDriverAccessor(driver, slug, () => primaryKeysFor(slug), viewModelFor(slug), () => options?.resolveDataPath?.(slug) ?? slug);
+			cache.set(slug, accessor);
+		}
+		return accessor;
+	}
+	return new Proxy({ collection: getAccessor }, { get(_target, prop) {
+		if (prop === "collection") return getAccessor;
+		if (typeof prop === "symbol") return void 0;
+		if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
+		return getAccessor(options?.resolveAccessor?.(prop) ?? toSnakeCase(prop));
+	} });
+}
+/**
+* Unwrap a Entity back into the flat row it was built from. `rowToEntity` keeps
+* the row untouched under `.values` and derives `.id` alongside it, so dropping
+* the wrapper is the whole operation — the address was never part of the row.
+*/
+function entityToRow(entity) {
+	return entity.values;
+}
+/**
+* Fluent query builder for the flat SDK data layer. Mirrors {@link QueryBuilder}
+* but resolves to `FindResult<M>` (flat rows) instead of Entity-wrapped
+* `FindResponse<M>`.
+*/
+var SdkQueryBuilder = class {
+	client;
+	params = { where: {} };
+	constructor(client) {
+		this.client = client;
+	}
+	where(columnOrCondition, operator, value) {
+		if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
+			const next = columnOrCondition;
+			this.params.logical = this.params.logical ? {
+				type: "and",
+				conditions: [this.params.logical, next]
+			} : next;
+			return this;
+		}
+		if (!this.params.where) this.params.where = {};
+		const column = columnOrCondition;
+		const condition = [operator, value];
+		const existing = this.params.where[column];
+		if (existing === void 0) this.params.where[column] = condition;
+		else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) this.params.where[column].push(condition);
+		else {
+			let firstCondition;
+			if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") firstCondition = existing;
+			else firstCondition = ["==", existing];
+			this.params.where[column] = [firstCondition, condition];
+		}
+		return this;
+	}
+	/** Called again, this adds a tie-breaker rather than replacing the sort. */
+	orderBy(column, direction = "asc", nulls) {
+		const existing = normalizeOrderBy(this.params.orderBy) ?? [];
+		const key = sortKeyToString(column);
+		this.params.orderBy = [...existing, nulls ? [
+			key,
+			direction,
+			nulls
+		] : [key, direction]];
+		return this;
+	}
+	limit(count) {
+		this.params.limit = count;
+		return this;
+	}
+	offset(count) {
+		this.params.offset = count;
+		return this;
+	}
+	search(searchString, options) {
+		this.params.searchString = searchString;
+		if (options?.explain !== void 0) this.params.searchExplain = options.explain;
+		return this;
+	}
+	vectorSearch(property, vector, options) {
+		this.params.vectorSearch = {
+			property,
+			vector,
+			...options?.distance !== void 0 && { distance: options.distance },
+			...options?.threshold !== void 0 && { threshold: options.threshold }
+		};
+		return this;
+	}
+	/**
+	* Load relations. Merges rather than replaces, so `.include("author")` then
+	* `.include({ comments: { limit: 5 } })` asks for both — a builder call that
+	* silently discarded an earlier one is the same defect `where` had.
+	*/
+	include(...relations) {
+		this.params.include = mergeIncludeSpecs(this.params.include, relations);
+		return this;
+	}
+	fields(...columns) {
+		this.params.fields = [...this.params.fields ?? [], ...columns];
+		return this;
+	}
+	distinct(enabled = true) {
+		this.params.distinct = enabled;
+		return this;
+	}
+	after(cursor) {
+		this.params.after = cursor;
+		return this;
+	}
+	async find() {
+		return this.client.find(this.params);
+	}
+	/** Aggregate the matching rows. See {@link SDKCollectionClient.aggregate}. */
+	async aggregate(params) {
+		return this.client.aggregate({
+			...params,
+			where: this.params.where,
+			logical: this.params.logical,
+			searchString: this.params.searchString
+		});
+	}
+	/**
+	* Page through everything this query matches, one row at a time.
+	*
+	* `.limit()` on the builder becomes the page size, so the ceiling on a
+	* single `find()` is not a ceiling on what the query can read.
+	*/
+	iterate(options) {
+		return this.client.iterate({
+			...this.params,
+			...this.params.limit !== void 0 && { pageSize: this.params.limit },
+			...options
+		});
+	}
+	/** Collect everything this query matches into one array. */
+	findAll(options) {
+		return this.client.findAll({
+			...this.params,
+			...this.params.limit !== void 0 && { pageSize: this.params.limit },
+			...options
+		});
+	}
+	/**
+	* Count the records matching this query.
+	*
+	* This used to answer `0` when the client had no `count` — a number, from a
+	* source that had not counted anything, indistinguishable from an empty
+	* collection. It now does what the client does, which on a source that
+	* cannot count is throw and say so.
+	*/
+	async count() {
+		return this.client.count(this.params);
+	}
+	listen(onUpdate, onError) {
+		return this.client.listen(this.params, onUpdate, onError);
+	}
+};
+/**
+* Refuse a write option this door cannot honour, by name, before anything is
+* written.
+*
+* The in-process accessor implements the same `SDKCollectionClient` as the HTTP
+* client, whose `ifMatch` is "Honoured on `update` and `delete`" — and its
+* writes took no options at all, so `rebase.data.posts.update(id, data, {
+* ifMatch: staleEtag })` overwrote the row and resolved. A precondition the
+* caller wrote, dropped without a word, is the worst thing a door can do with
+* it. The driver's `save` has no precondition and no idempotency store to hand
+* these to, so they are refused rather than ignored. An `undefined` value is no
+* option, as it is over HTTP: `etagOf(row)` is `undefined` for a row that
+* carries no version, and that means "write unconditionally".
+*/
+function refuseUnhonouredWriteOptions(method, slug, options) {
+	const unsupported = ["ifMatch", "idempotencyKey"].filter((key) => options?.[key]);
+	if (unsupported.length === 0) return;
+	throw new RebaseClientError(`${method}() on "${slug}" in-process (context.data, rebase.data) cannot honour ${unsupported.join(" or ")}: this door has no ${unsupported.includes("ifMatch") ? "precondition check" : "idempotency store"}, and ignoring the option would write as though it had been checked. Drop it here, or send the write through the HTTP client, which honours it.`, {
+		code: "UNSUPPORTED_OPTION",
+		details: {
+			method,
+			options: unsupported
+		}
+	});
+}
+/**
+* Wrap a Entity-shaped {@link CollectionAccessor} into a flat
+* {@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, slug = "collection") {
+	const client = {
+		async find(params) {
+			const res = await snap.find(params);
+			return {
+				data: res.data.map(entityToRow),
+				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, options) {
+			const s = await snap.findById(id, options);
+			return s ? entityToRow(s) : void 0;
+		},
+		async get(id) {
+			const s = await snap.findById(id);
+			if (!s) throw new RebaseApiError(`No record with id ${JSON.stringify(String(id))} in "${slug}".`, {
+				status: 404,
+				code: "NOT_FOUND"
+			});
+			return entityToRow(s);
+		},
+		async create(data, id, options) {
+			refuseUnhonouredWriteOptions("create", slug, options);
+			return entityToRow(await snap.create(data, id));
+		},
+		async createMany(data, options) {
+			refuseUnhonouredWriteOptions("createMany", slug, options);
+			if (!Array.isArray(data)) throw new RebaseClientError("createMany expects an array of records.", { code: "INVALID_BULK_BODY" });
+			if (data.length === 0) return [];
+			if (!snap.createMany) throw new Error("Bulk writes are not supported by this collection's data source. Fall back to create() per record.");
+			return (await snap.createMany(data, {
+				upsert: options?.upsert,
+				onConflict: options?.onConflict
+			})).map(entityToRow);
+		},
+		/**
+		* One row through the bulk path, because the bulk path is where the
+		* conflict target lives.
+		*
+		* `CollectionAccessor` has no single-row upsert and adding one would
+		* mean a second way to say the same thing to the same driver method —
+		* `saveMany` already takes `upsert` and `onConflict`, and a batch of
+		* one is exactly an upsert of one.
+		*/
+		async upsert(data, options) {
+			refuseUnhonouredWriteOptions("upsert", slug, options);
+			if (!snap.createMany) throw new Error("Upsert is not supported by this collection's data source: it needs a bulk write, which this driver does not implement. Fall back to create() or update().");
+			const row = (await snap.createMany([data], {
+				upsert: true,
+				onConflict: options?.onConflict
+			}))[0];
+			if (!row) throw new Error(`Upsert into "${slug}" returned no row.`);
+			return entityToRow(row);
+		},
+		async update(id, data, options) {
+			refuseUnhonouredWriteOptions("update", slug, options);
+			return entityToRow(await snap.update(id, data));
+		},
+		async updateMany(updates, options) {
+			refuseUnhonouredWriteOptions("updateMany", slug, options);
+			if (!Array.isArray(updates)) throw new RebaseClientError("updateMany expects an array of { id, data } entries.", { code: "INVALID_BULK_BODY" });
+			if (updates.length === 0) return [];
+			if (!snap.updateMany) throw new Error("Bulk updates are not supported by this collection's data source. Fall back to update() per record.");
+			return (await snap.updateMany(updates.map((u) => ({
+				id: u.id,
+				data: u.data
+			})))).map(entityToRow);
+		},
+		async delete(id, options) {
+			refuseUnhonouredWriteOptions("delete", slug, options);
+			return snap.delete(id);
+		},
+		async deleteMany(ids, options) {
+			refuseUnhonouredWriteOptions("deleteMany", slug, options);
+			if (!Array.isArray(ids)) throw new RebaseClientError("deleteMany expects an array of ids.", { code: "INVALID_BULK_BODY" });
+			if (ids.length === 0) return;
+			if (!snap.deleteMany) throw new Error("Bulk deletes are not supported by this collection's data source. Fall back to delete() per record.");
+			await snap.deleteMany(ids);
+		},
+		count: snap.count ? (params) => snap.count(params) : unsupportedMethod(noCount(slug)),
+		listen: snap.listen ? (params, onUpdate, onError) => snap.listen(params, (res) => onUpdate({
+			data: res.data.map(entityToRow),
+			meta: res.meta
+		}), onError) : unsupportedMethod(noRealtime(slug)),
+		listenById: snap.listenById ? (id, onUpdate, onError, options) => snap.listenById(id, (s) => onUpdate(s ? entityToRow(s) : void 0), onError, options) : unsupportedMethod(noRealtime(slug)),
+		listenCount: snap.listenCount ? (params, onCount, onError) => snap.listenCount(params, onCount, onError) : unsupportedMethod(noRealtime(slug)),
+		where(columnOrCondition, operator, value) {
+			const builder = new SdkQueryBuilder(client);
+			if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+			return builder.where(columnOrCondition, operator, value);
+		},
+		orderBy: (column, direction, nulls) => new SdkQueryBuilder(client).orderBy(column, direction, nulls),
+		limit: (count) => new SdkQueryBuilder(client).limit(count),
+		offset: (count) => new SdkQueryBuilder(client).offset(count),
+		search: (searchString) => new SdkQueryBuilder(client).search(searchString),
+		vectorSearch: (property, vector, options) => new SdkQueryBuilder(client).vectorSearch(property, vector, options),
+		include: (...relations) => new SdkQueryBuilder(client).include(...relations),
+		fields: (...columns) => new SdkQueryBuilder(client).fields(...columns),
+		distinct: (enabled) => new SdkQueryBuilder(client).distinct(enabled),
+		after: (cursor) => new SdkQueryBuilder(client).after(cursor),
+		aggregate: snap.aggregate ? (params) => snap.aggregate(params) : unsupportedMethod(noAggregate(slug)),
+		trash: toSdkTrashClient(snap, slug, () => client)
+	};
+	return client;
+}
+/**
+* {@link SDKCollectionClient.trash} over an accessor's
+* {@link CollectionAccessor.trash}: the same API the browser client has. A
+* restore is the client's own `update`/`updateMany` setting the soft-delete
+* field to `null`, so it keeps their refusals and their answer.
+*/
+function toSdkTrashClient(snap, slug, client) {
+	const trash = snap.trash;
+	if (!trash) return {
+		find: unsupportedMethod(noTrash(slug)),
+		count: unsupportedMethod(noTrash(slug)),
+		restore: unsupportedMethod(noTrash(slug)),
+		restoreMany: unsupportedMethod(noTrash(slug)),
+		purge: unsupportedMethod(noTrash(slug)),
+		purgeMany: unsupportedMethod(noTrash(slug))
+	};
+	const field = (options) => options?.field ?? DEFAULT_SOFT_DELETE_FIELD;
+	return {
+		async find(params) {
+			const res = await trash.find(params);
+			return {
+				data: res.data.map(entityToRow),
+				meta: res.meta
+			};
+		},
+		count: (params) => trash.count(params),
+		restore: (id, options) => client().update(id, { [field(options)]: null }, writeOptionsOf(options)),
+		restoreMany(ids, options) {
+			if (!Array.isArray(ids)) return Promise.reject(new RebaseClientError("trash.restoreMany expects an array of ids.", { code: "INVALID_BULK_BODY" }));
+			const data = { [field(options)]: null };
+			return client().updateMany(ids.map((id) => ({
+				id,
+				data
+			})), writeOptionsOf(options));
+		},
+		async purge(id, options) {
+			refuseUnhonouredWriteOptions("trash.purge", slug, options);
+			await trash.purge(id);
+		},
+		async purgeMany(ids, options) {
+			refuseUnhonouredWriteOptions("trash.purgeMany", slug, options);
+			if (!Array.isArray(ids)) throw new RebaseClientError("trash.purgeMany expects an array of ids.", { code: "INVALID_BULK_BODY" });
+			if (ids.length === 0) return;
+			if (!trash.purgeMany) throw new Error("Bulk deletes are not supported by this collection's data source. Fall back to trash.purge() per record.");
+			await trash.purgeMany(ids);
+		}
+	};
+}
+/** A {@link RestoreOptions} without its `field`: the write options it carries. */
+function writeOptionsOf(options) {
+	if (!options) return void 0;
+	const { field: _field, ...rest } = options;
+	return rest;
+}
+/**
+* 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 panel renders.
+*/
+function toEntityAccessor(sdk, slug, getPks = () => [], toViewModel, viewModelSource = () => void 0) {
+	const accessor = {
+		async find(params) {
+			const res = await sdk.find(params);
+			return {
+				data: res.data.map((row) => rowToEntity(row, slug, getPks(), toViewModel)),
+				meta: res.meta
+			};
+		},
+		async findById(id, options) {
+			const row = await sdk.findById(id, options);
+			return row ? rowToEntity(row, slug, getPks(), toViewModel) : void 0;
+		},
+		async create(data, id) {
+			return rowToEntity(await sdk.create(data, id), slug, getPks(), toViewModel);
+		},
+		createMany: sdk.createMany ? async (data, options) => {
+			return (await sdk.createMany(data, options)).map((row) => rowToEntity(row, slug, getPks(), toViewModel));
+		} : void 0,
+		async update(id, data, options) {
+			const row = options?.ifMatch ? await sdk.update(id, data, { ifMatch: options.ifMatch }) : await sdk.update(id, data);
+			if (!row) throw new Error(`Update returned no data for id ${id}`);
+			return rowToEntity(row, slug, getPks(), toViewModel);
+		},
+		delete(id) {
+			return sdk.delete(id);
+		},
+		count: isUnsupported(sdk.count) ? void 0 : (params) => sdk.count(params),
+		aggregate: isUnsupported(sdk.aggregate) ? void 0 : (params) => sdk.aggregate(params),
+		listen: isUnsupported(sdk.listen) ? void 0 : (params, onUpdate, onError) => {
+			let built = /* @__PURE__ */ new WeakMap();
+			let builtWith;
+			return sdk.listen(params, (res) => {
+				const pks = getPks();
+				const source = viewModelSource();
+				if (!builtWith || builtWith[0] !== pks || builtWith[1] !== source) {
+					built = /* @__PURE__ */ new WeakMap();
+					builtWith = [pks, source];
+				}
+				onUpdate({
+					data: res.data.map((row) => {
+						let entity = built.get(row);
+						if (!entity) {
+							entity = rowToEntity(row, slug, pks, toViewModel);
+							built.set(row, entity);
+						}
+						return entity;
+					}),
+					meta: res.meta
+				});
+			}, onError);
+		},
+		listenById: isUnsupported(sdk.listenById) ? void 0 : (id, onUpdate, onError, options) => sdk.listenById(id, (row) => onUpdate(row ? rowToEntity(row, slug, getPks(), toViewModel) : void 0), onError, options),
+		listenCount: isUnsupported(sdk.listenCount) ? void 0 : (params, onCount, onError) => sdk.listenCount(params, onCount, onError),
+		trash: !sdk.trash || isUnsupported(sdk.trash.find) ? void 0 : {
+			async find(params) {
+				const res = await sdk.trash.find(params);
+				return {
+					data: res.data.map((row) => rowToEntity(row, slug, getPks(), toViewModel)),
+					meta: res.meta
+				};
+			},
+			count: (params) => sdk.trash.count(params),
+			purge: (id) => sdk.trash.purge(id),
+			purgeMany: (ids) => sdk.trash.purgeMany(ids)
+		},
+		where(columnOrCondition, operator, value) {
+			const builder = new QueryBuilder(accessor);
+			if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+			return builder.where(columnOrCondition, operator, value);
+		},
+		orderBy: (column, direction) => new QueryBuilder(accessor).orderBy(column, direction),
+		limit: (count) => new QueryBuilder(accessor).limit(count),
+		offset: (count) => new QueryBuilder(accessor).offset(count),
+		search: (searchString) => new QueryBuilder(accessor).search(searchString),
+		vectorSearch: (property, vector, options) => new QueryBuilder(accessor).vectorSearch(property, vector, options),
+		include: (...relations) => new QueryBuilder(accessor).include(...relations)
+	};
+	return accessor;
+}
+/**
+* Wrap a flat {@link RebaseSdkData} into a Entity-shaped {@link RebaseData}.
+*
+* 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
+* admin `RebaseDataContext` — without it the admin renders rows with only their
+* `id`.
+*/
+/**
+* Only the by-slug accessor is asked for, so only that is required.
+*
+* Taking a whole `RebaseSdkData` meant taking `RebaseSdkData<unknown>`, whose
+* dynamic branch is an index signature — and no `RebaseSdkData<DB>` satisfies
+* it, because its own `collection` method is not a `SDKCollectionClient`. So a
+* caller holding a *typed* client could not pass it to a function that reads
+* one method off it, and that method is identical on every instantiation.
+*/
+function wrapAsEntityData(sdkData, options) {
+	const cache = /* @__PURE__ */ new Map();
+	const primaryKeysFor = createPrimaryKeyResolver(options);
+	const viewModelFor = createViewModelConverter(options);
+	function getAccessor(slug) {
+		let accessor = cache.get(slug);
+		if (!accessor) {
+			accessor = toEntityAccessor(sdkData.collection(slug), slug, () => primaryKeysFor(slug), viewModelFor(slug), () => options?.resolveCollection?.(slug));
+			cache.set(slug, accessor);
+		}
+		return accessor;
+	}
+	return new Proxy({ collection: getAccessor }, { get(_target, prop) {
+		if (prop === "collection") return getAccessor;
+		if (typeof prop === "symbol") return void 0;
+		if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
+		return getAccessor(toSnakeCase(prop));
+	} });
+}
+/**
+* Wrap a Entity-shaped {@link RebaseData} into a flat {@link RebaseSdkData}.
+*
+* Every collection accessor is adapted to return flat rows. Use this to derive
+* the flat SDK data layer (`context.data`) from an existing Entity data layer
+* — e.g. the admin routes its Entity data via `useData()` and exposes the
+* same routing as flat `context.data` for callbacks by wrapping it here.
+*/
+function wrapAsSdkData(entityData, options) {
+	const cache = /* @__PURE__ */ new Map();
+	function getAccessor(slug) {
+		let accessor = cache.get(slug);
+		if (!accessor) {
+			accessor = toSdkCollectionClient(entityData.collection(slug), slug);
+			cache.set(slug, accessor);
+		}
+		return accessor;
+	}
+	return new Proxy({ collection: getAccessor }, { get(_target, prop) {
+		if (prop === "collection") return getAccessor;
+		if (typeof prop === "symbol") return void 0;
+		if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
+		return getAccessor(options?.resolveAccessor?.(prop) ?? toSnakeCase(prop));
+	} });
+}
+/**
+* Build a flat {@link RebaseSdkData} from a `DataDriver`.
+*
+* This is the developer-facing SDK data layer used by backend framework
+* callbacks & scripts (`context.data` / `rebase.dataAsAdmin`). It returns flat rows —
+* 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.
+*
+* `options.resolveAccessor` names the slug a property is (see
+* `createAccessorSlugResolver`); absent, `data.myNotes` is `my_notes`.
+*/
+function buildSdkData(driver, options) {
+	return wrapAsSdkData(buildRebaseData(driver), options);
+}
+//#endregion
+export { aggregateAlias, buildRebaseData, buildSdkData, wrapAsEntityData, wrapAsSdkData };
+
+//# sourceMappingURL=buildRebaseData.es.js.map