@rebasepro/common 0.8.0 → 0.9.0

package/dist/index.umd.js

@@ -83,7 +83,7 @@
 		else return null;
 	}
 	/**
-	* Update the automatic values in an entity before save
+	* Update the automatic values in a entity before save
 	* @group Driver
 	*/
 	function updateDateAutoValues({ inputValues, properties, status, timestampNowValue }) {
@@ -95,7 +95,7 @@
 		}) ?? {};
 	}
 	/**
-	* Add missing required fields, expected in the collection, to the values of an entity
+	* Add missing required fields, expected in the collection, to the values of a entity
 	* @param values
 	* @param properties
 	* @group Driver
@@ -265,7 +265,7 @@
 		return collection.localChangesBackup;
 	}
 	/**
-	* Returns the primary keys for an entity collection by inspecting the properties
+	* Returns the primary keys for a entity collection by inspecting the properties
 	* and finding any properties with `isId`.
 	* Fallbacks to `["id"]` if no properties are marked as `isId: true`.
 	* @param collection
@@ -809,22 +809,56 @@
 	* {@link evaluatePolicy}); the Postgres schema generators call it so that DDL
 	* and the admin UI derive from the exact same expression.
 	*/
-	function policyToPostgres(expr, collection) {
+	function policyToPostgres(expr, collection, options) {
+		return compile(expr, {
+			fieldCollection: collection,
+			fieldPrefix: "",
+			outerCollection: collection,
+			outerPrefix: "",
+			resolveCollection: options?.resolveCollection,
+			alias: { n: 0 }
+		});
+	}
+	function compile(expr, scope) {
 		switch (expr.kind) {
 			case "true": return "true";
 			case "false": return "false";
-			case "and": return expr.operands.length === 0 ? "true" : expr.operands.map((o) => `(${policyToPostgres(o, collection)})`).join(" AND ");
-			case "or": return expr.operands.length === 0 ? "false" : expr.operands.map((o) => `(${policyToPostgres(o, collection)})`).join(" OR ");
+			case "and": return expr.operands.length === 0 ? "true" : expr.operands.map((o) => `(${compile(o, scope)})`).join(" AND ");
+			case "or": return expr.operands.length === 0 ? "false" : expr.operands.map((o) => `(${compile(o, scope)})`).join(" OR ");
 			case "not":
 				if (expr.operand.kind === "authenticated") return "auth.uid() IS NULL";
-				return `NOT (${policyToPostgres(expr.operand, collection)})`;
-			case "compare": return `${operandToSql(expr.left, collection)} ${COMPARE_SQL[expr.op]} ${operandToSql(expr.right, collection)}`;
+				return `NOT (${compile(expr.operand, scope)})`;
+			case "compare": return `${operandToSql(expr.left, scope)} ${COMPARE_SQL[expr.op]} ${operandToSql(expr.right, 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";
+			case "existsIn": return compileExistsIn(expr, scope);
 			case "raw": return expr.sql.replace(/\{(\w+)\}/g, (_, col) => col);
 		}
 	}
+	/**
+	* Compiles `existsIn` to a correlated `EXISTS (SELECT 1 FROM <join> WHERE ...)`.
+	* Inside the subquery, `field` operands bind to the aliased join table and
+	* `outerField` operands bind to the (table-qualified) outer RLS row.
+	*/
+	function compileExistsIn(expr, scope) {
+		const join = scope.resolveCollection?.(expr.collection);
+		const joinTable = join ? getTableName(join) : (0, _rebasepro_utils.toSnakeCase)(expr.collection);
+		const joinSchema = schemaOf(join) ?? schemaOf(scope.outerCollection) ?? "public";
+		const alias = `_ex${scope.alias.n++}`;
+		const outerTable = scope.outerCollection ? getTableName(scope.outerCollection) : void 0;
+		const outerSchema = schemaOf(scope.outerCollection) ?? "public";
+		const outerPrefix = outerTable ? `"${outerSchema}"."${outerTable}".` : "";
+		const innerScope = {
+			fieldCollection: join,
+			fieldPrefix: `"${alias}".`,
+			outerCollection: scope.outerCollection,
+			outerPrefix,
+			resolveCollection: scope.resolveCollection,
+			alias: scope.alias
+		};
+		return `EXISTS (SELECT 1 FROM "${joinSchema}"."${joinTable}" "${alias}" WHERE ${compile(expr.where, innerScope)})`;
+	}
 	var COMPARE_SQL = {
 		eq: "=",
 		neq: "!=",
@@ -833,14 +867,18 @@
 		gt: ">",
 		gte: ">="
 	};
-	function operandToSql(operand, collection) {
+	function operandToSql(operand, scope) {
 		switch (operand.kind) {
-			case "field": return resolveColumnName(operand.name, collection);
+			case "field": return `${scope.fieldPrefix}${resolveColumnName(operand.name, scope.fieldCollection)}`;
+			case "outerField": return `${scope.outerPrefix}${resolveColumnName(operand.name, scope.outerCollection)}`;
 			case "literal": return quoteLiteral(operand.value);
 			case "authUid": return "auth.uid()";
 			case "authRoles": return "string_to_array(auth.roles(), ',')";
 		}
 	}
+	function schemaOf(collection) {
+		return collection?.schema || void 0;
+	}
 	function resolveColumnName(propName, collection) {
 		const prop = collection?.properties?.[propName];
 		if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
@@ -883,6 +921,7 @@
 				return expr.roles.every((r) => r === "public" || userRoles.includes(r));
 			}
 			case "authenticated": return ctx.uid != null;
+			case "existsIn": return "unknown";
 			case "raw": return "unknown";
 		}
 	}
@@ -920,6 +959,7 @@
 					known: true,
 					value: ctx.entity.values[operand.name]
 				};
+			case "outerField": return { known: false };
 		}
 	}
 	function evaluateCompare(op, left, right, ctx) {
@@ -1131,7 +1171,7 @@
 				} else {
 					entityId = remainingPath;
 					remainingPath = "";
-					console.warn(`resolveCollectionPathIds: Path seems to end with an entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
+					console.warn(`resolveCollectionPathIds: Path seems to end with a entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
 				}
 				resolvedPathParts.push(entityId);
 				currentCollections = getSubcollections(foundCollection);
@@ -1287,9 +1327,12 @@
 	//#endregion
 	//#region src/util/builders.ts
 	/**
-	* Identity function we use to defeat the type system of Typescript and build
-	* collection views with all its properties
-	* @param collection
+	* @deprecated Use {@link defineCollection} instead — it infers property
+	* types automatically (autocomplete on `titleProperty`, `sort`,
+	* `propertiesOrder`, callbacks) without manual generics.
+	* `buildCollection` is kept for FireCMS migration compatibility and will
+	* be removed before 1.0.
+	*
 	* @group Builder
 	*/
 	function buildCollection(collection) {
@@ -1303,68 +1346,16 @@
 		return collection;
 	}
 	/**
-	* Identity function we use to defeat the type system of Typescript and preserve
-	* the property keys.
-	* @param property
+	* @deprecated Use plain typed property objects with {@link defineCollection}
+	* instead — `defineCollection` infers property types automatically, making
+	* this wrapper unnecessary. `buildProperty` is kept for FireCMS migration
+	* compatibility and will be removed before 1.0.
+	*
 	* @group Builder
 	*/
 	function buildProperty(property) {
 		return property;
 	}
-	/**
-	* Identity function we use to defeat the type system of Typescript and preserve
-	* the properties keys.
-	* @param properties
-	* @group Builder
-	*/
-	function buildProperties(properties) {
-		return properties;
-	}
-	/**
-	* Identity function we use to defeat the type system of Typescript and preserve
-	* the properties keys.
-	* @param propertiesOrBuilder
-	* @group Builder
-	*/
-	function buildPropertiesOrBuilder(propertiesOrBuilder) {
-		return propertiesOrBuilder;
-	}
-	/**
-	* Identity function we use to defeat the type system of Typescript and preserve
-	* the properties keys.
-	* @param enumValues
-	* @group Builder
-	*/
-	function buildEnum(enumValues) {
-		return enumValues;
-	}
-	/**
-	* Identity function we use to defeat the type system of Typescript and preserve
-	* the properties keys.
-	* @param enumValueConfig
-	* @group Builder
-	*/
-	function buildEnumValueConfig(enumValueConfig) {
-		return enumValueConfig;
-	}
-	/**
-	* Identity function we use to defeat the type system of Typescript and preserve
-	* the properties keys.
-	* @param callbacks
-	* @group Builder
-	*/
-	function buildEntityCallbacks(callbacks) {
-		return callbacks;
-	}
-	/**
-	* Identity function we use to defeat the type system of Typescript and build
-	* additional field delegates views with all its properties
-	* @param additionalFieldDelegate
-	* @group Builder
-	*/
-	function buildAdditionalFieldDelegate(additionalFieldDelegate) {
-		return additionalFieldDelegate;
-	}
 	//#endregion
 	//#region src/util/storage.ts
 	/**
@@ -1500,16 +1491,17 @@
 	}
 	/**
 	* Helper function to extract field-level PropertyCallbacks from a properties schema
-	* and wrap them into an EntityCallbacks object recursively.
+	* 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 processedValues = await processProperties(properties, props.entity.values, props.entity.values, props, "afterRead");
+			const row = props.row;
+			const processedValues = await processProperties(properties, row, row, props, "afterRead");
 			return {
-				...props.entity,
-				values: processedValues
+				...props.row,
+				...processedValues
 			};
 		};
 		if (hasPropertyCallbacks(properties, "beforeSave")) propertyCallbacks.beforeSave = async (props) => {
@@ -1696,6 +1688,84 @@
 		return result;
 	}
 	//#endregion
+	//#region src/util/filter-operator-resolution.ts
+	/**
+	* Default operators offered per property type, before engine capabilities and
+	* per-property narrowing are applied. These mirror what the built-in filter
+	* fields can render.
+	*/
+	var COMPARISON_OPS = [
+		"==",
+		"!=",
+		">",
+		">=",
+		"<",
+		"<="
+	];
+	var NULL_CHECK_OPS = ["is-null", "is-not-null"];
+	var MEMBERSHIP_OPS = ["in", "not-in"];
+	var PATTERN_OPS = [
+		"like",
+		"ilike",
+		"not-like",
+		"not-ilike"
+	];
+	var DEFAULT_OPS_BY_TYPE = {
+		string: [
+			...COMPARISON_OPS,
+			...MEMBERSHIP_OPS,
+			...PATTERN_OPS,
+			...NULL_CHECK_OPS
+		],
+		number: [
+			...COMPARISON_OPS,
+			...MEMBERSHIP_OPS,
+			...NULL_CHECK_OPS
+		],
+		date: [...COMPARISON_OPS, ...NULL_CHECK_OPS],
+		boolean: [
+			"==",
+			"!=",
+			...NULL_CHECK_OPS
+		],
+		reference: [
+			"==",
+			"!=",
+			...MEMBERSHIP_OPS,
+			...NULL_CHECK_OPS
+		],
+		relation: [
+			"==",
+			"!=",
+			...MEMBERSHIP_OPS,
+			...NULL_CHECK_OPS
+		]
+	};
+	/** Operators offered when the property is an *array of* a filterable type. */
+	var ARRAY_OPS = ["array-contains", "array-contains-any"];
+	/**
+	* Resolve which filter operators the UI should offer for a property.
+	*
+	* The result is the **intersection** of three sets:
+	* 1. what the engine can execute — {@link DataSourceCapabilities.filterOperators}
+	*    (e.g. Firestore cannot run the LIKE family);
+	* 2. what makes sense for the property type (e.g. no `>` on booleans);
+	* 3. the developer's optional narrowing — `property.ui.filterOperators`.
+	*
+	* Returns an empty array when the property is not filterable (either by
+	* type, or because the developer disabled it with `filterOperators: []`).
+	*
+	* @group Models
+	*/
+	function resolveFilterOperators({ property, isArray, engine }) {
+		const typeDefaults = isArray ? ARRAY_OPS : DEFAULT_OPS_BY_TYPE[property.type] ?? [];
+		if (typeDefaults.length === 0) return [];
+		const engineOps = new Set((0, _rebasepro_types.getDataSourceCapabilities)(engine).filterOperators ?? _rebasepro_types.ALL_WHERE_FILTER_OPS);
+		const narrowing = property.ui?.filterOperators;
+		const narrowingSet = narrowing !== void 0 ? new Set(narrowing) : void 0;
+		return typeDefaults.filter((op) => engineOps.has(op) && (narrowingSet === void 0 || narrowingSet.has(op)));
+	}
+	//#endregion
 	//#region src/data/resolveDataSource.ts
 	/**
 	* Build a keyed registry from a list of {@link DataSourceDefinition}s.
@@ -1774,7 +1844,7 @@
 		rawCollectionsBySlug = /* @__PURE__ */ new Map();
 		rawRootCollections = [];
 		cachedRawCollectionsList = null;
-		lastRawInputSnapshot = null;
+		lastRawInputEntity = null;
 		constructor(collections, dataSources) {
 			if (dataSources) this.dataSources = dataSources;
 			if (collections) this.registerMultiple(collections);
@@ -1804,12 +1874,12 @@
 		* Returns true if the collections have changed, false otherwise.
 		*
 		* Idempotent: compares the raw input (before normalization) against a stored
-		* snapshot. Only re-normalizes and re-registers when the raw input actually changed.
+		* entity. Only re-normalizes and re-registers when the raw input actually changed.
 		* @param collections
 		*/
 		registerMultiple(collections) {
-			const rawSnapshot = collections.map((c) => (0, _rebasepro_utils.removeFunctions)(c));
-			if (this.lastRawInputSnapshot && (0, fast_equals.deepEqual)(this.lastRawInputSnapshot, rawSnapshot)) return false;
+			const rawEntity = collections.map((c) => (0, _rebasepro_utils.removeFunctions)(c));
+			if (this.lastRawInputEntity && (0, fast_equals.deepEqual)(this.lastRawInputEntity, rawEntity)) return false;
 			this.reset();
 			collections.forEach((c) => {
 				if (c.slug) this.collectionsBySlug.set(c.slug, c);
@@ -1833,7 +1903,7 @@
 					this._registerRecursively(this.normalizeCollection({ ...subCollection }), (0, _rebasepro_utils.deepClone)(subCollection));
 				});
 			});
-			this.lastRawInputSnapshot = rawSnapshot;
+			this.lastRawInputEntity = rawEntity;
 			return true;
 		}
 		register(collection, rawCollection) {
@@ -2253,7 +2323,7 @@
 		* client.collection('users').orderBy('createdAt', 'desc').find()
 		*/
 		orderBy(column, direction = "asc") {
-			this.params.orderBy = `${column}:${direction}`;
+			this.params.orderBy = [column, direction];
 			return this;
 		}
 		/**
@@ -2316,32 +2386,69 @@
 	* PostgREST-style dot-syntax strings (`eq.active`, `gt.18`, `in.(a,b)`).
 	* Everything else speaks `FilterValues` exclusively.
 	*
+	* Wire-format values are always strings — the wire format carries no type
+	* metadata, so type coercion is the responsibility of the server-side data
+	* driver which has access to the collection schema.
+	*
+	* Commas inside list values are backslash-escaped (`\,`), and literal
+	* backslashes are escaped as `\\`.
+	*
 	* @module
 	*/
 	/**
-	* Coerce a raw querystring value to its natural JS type.
-	* - `"true"` / `"false"` → boolean
-	* - `"null"` → null
-	* - Numeric strings → number
-	* - Everything else → string (unchanged)
-	*/
-	function coerceValue(raw) {
-		if (raw === "true") return true;
-		if (raw === "false") return false;
-		if (raw === "null") return null;
-		if (raw !== "" && !isNaN(Number(raw))) return Number(raw);
-		return raw;
-	}
-	/**
 	* Serialize a JS value to its querystring representation.
+	* `null` is serialized as the literal string `"null"`.
 	*/
 	function stringifyValue(value) {
 		if (value === null) return "null";
-		if (typeof value === "boolean") return String(value);
 		return String(value);
 	}
 	/**
-	* Serialize a single condition tuple to a PostgREST dot-string.
+	* Escape a single list item for the wire format.
+	* `\` → `\\`, `,` → `\,`
+	*/
+	function escapeListItem(value) {
+		return value.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
+	}
+	/**
+	* Unescape a single list item from the wire format.
+	* `\\` → `\`, `\,` → `,`
+	*/
+	function unescapeListItem(value) {
+		let result = "";
+		for (let i = 0; i < value.length; i++) if (value[i] === "\\" && i + 1 < value.length) {
+			result += value[i + 1];
+			i++;
+		} else result += value[i];
+		return result;
+	}
+	/**
+	* Split a parenthesized list string on unescaped commas.
+	* Input is the content between `(` and `)`.
+	*
+	* @example
+	* splitListItems("admin,editor")          // ["admin", "editor"]
+	* splitListItems("hello\\, world,foo")    // ["hello, world", "foo"]
+	*/
+	function splitListItems(inner) {
+		const items = [];
+		let current = "";
+		for (let i = 0; i < inner.length; i++) if (inner[i] === "\\" && i + 1 < inner.length) {
+			current += inner[i] + inner[i + 1];
+			i++;
+		} else if (inner[i] === ",") {
+			items.push(unescapeListItem(current));
+			current = "";
+		} else current += inner[i];
+		items.push(unescapeListItem(current));
+		return items;
+	}
+	var REST_OP_LOOKUP = _rebasepro_types.REST_TO_CANONICAL;
+	var CANONICAL_OP_LOOKUP = _rebasepro_types.CANONICAL_TO_REST;
+	/**
+	* Serialize a single canonical condition tuple to a PostgREST dot-string.
+	*
+	* Throws `TypeError` if the input is not a valid `[WhereFilterOp, unknown]` tuple.
 	*
 	* @example
 	* serializeTuple(["==", "active"])           // "eq.active"
@@ -2349,22 +2456,20 @@
 	* serializeTuple([">=", 18])                 // "gte.18"
 	*/
 	function serializeTuple(tuple) {
-		if (typeof tuple === "string") {
-			if (tuple.includes(".")) {
-				const dotIndex = tuple.indexOf(".");
-				if (_rebasepro_types.REST_TO_CANONICAL[tuple.substring(0, dotIndex)]) return tuple;
-			}
-			return tuple;
-		}
-		if (!Array.isArray(tuple) || tuple.length !== 2 || typeof tuple[0] !== "string" || !_rebasepro_types.CANONICAL_TO_REST[tuple[0]]) return `eq.${stringifyValue(tuple)}`;
+		if (!Array.isArray(tuple) || tuple.length !== 2) throw new TypeError(`serializeTuple: expected a [WhereFilterOp, value] tuple, got ${JSON.stringify(tuple)}`);
 		const [op, value] = tuple;
-		const restOp = _rebasepro_types.CANONICAL_TO_REST[op];
-		if (Array.isArray(value)) return `${restOp}.(${value.map(stringifyValue).join(",")})`;
+		if (typeof op !== "string") throw new TypeError(`serializeTuple: operator must be a string, got ${typeof op}`);
+		const restOp = CANONICAL_OP_LOOKUP[op];
+		if (!restOp) throw new TypeError(`serializeTuple: unknown operator "${op}". Valid operators: ${Object.keys(_rebasepro_types.CANONICAL_TO_REST).join(", ")}`);
+		if (Array.isArray(value)) return `${restOp}.(${value.map((v) => escapeListItem(stringifyValue(v))).join(",")})`;
 		return `${restOp}.${stringifyValue(value)}`;
 	}
 	/**
-	* Convert `FilterValues` to a PostgREST-style querystring record.
+	* Convert `FilterValues` (or `WireFilterValues`) to a PostgREST-style
+	* querystring record.
 	*
+	* - Canonical `[WhereFilterOp, value]` tuples are serialized strictly.
+	* - Pre-serialized PostgREST strings (e.g. `"eq.published"`) are passed through.
 	* - Single conditions produce a string value.
 	* - Multiple conditions on the same field produce a string array (repeated params).
 	*
@@ -2374,11 +2479,19 @@
 	*
 	* serializeFilter({ age: [[">=", 18], ["<", 65]] })
 	* // → { age: ["gte.18", "lt.65"] }
+	*
+	* // Pre-serialized strings pass through unchanged:
+	* serializeFilter({ status: "eq.published" })
+	* // → { status: "eq.published" }
 	*/
 	function serializeFilter(filter) {
 		const result = {};
 		for (const [field, condition] of Object.entries(filter)) {
 			if (condition === void 0) continue;
+			if (typeof condition === "string") {
+				result[field] = condition;
+				continue;
+			}
 			if (Array.isArray(condition) && condition.length > 0 && Array.isArray(condition[0])) result[field] = condition.map(serializeTuple);
 			else result[field] = serializeTuple(condition);
 		}
@@ -2387,18 +2500,24 @@
 	/**
 	* Parse a single PostgREST dot-string into a `[WhereFilterOp, unknown]` tuple.
 	*
-	* If the string doesn't match a known operator prefix, falls back to
+	* All values are returned as strings — the wire format carries no type
+	* metadata, so coercion is the data driver's responsibility.
+	*
+	* If the string doesn't match a known operator prefix, it falls back to
 	* `["==", originalString]` (treating the whole string as an equality value).
+	* This intentional defense handles values like `"user@host.com"` or
+	* `"1.2.3"` that happen to contain dots.
 	*/
 	function deserializeSingle(raw) {
 		const dotIndex = raw.indexOf(".");
-		if (dotIndex === -1) return ["==", coerceValue(raw)];
+		if (dotIndex === -1) return ["==", raw];
 		const prefix = raw.substring(0, dotIndex);
 		const rest = raw.substring(dotIndex + 1);
-		const canonicalOp = _rebasepro_types.REST_TO_CANONICAL[prefix];
+		const canonicalOp = REST_OP_LOOKUP[prefix];
 		if (!canonicalOp) return ["==", raw];
-		if (rest.startsWith("(") && rest.endsWith(")")) return [canonicalOp, rest.slice(1, -1).split(",").map((s) => coerceValue(s.trim()))];
-		return [canonicalOp, coerceValue(rest)];
+		if (_rebasepro_types.NULL_OPS.has(canonicalOp)) return [canonicalOp, null];
+		if (rest.startsWith("(") && rest.endsWith(")")) return [canonicalOp, splitListItems(rest.slice(1, -1))];
+		return [canonicalOp, rest];
 	}
 	/**
 	* Convert a PostgREST-style querystring record to `FilterValues`.
@@ -2411,7 +2530,7 @@
 	* // → { status: ["==", "active"] }
 	*
 	* deserializeFilter({ age: ["gte.18", "lt.65"] })
-	* // → { age: [[">=", 18], ["<", 65]] }
+	* // → { age: [[">=", "18"], ["<", "65"]] }
 	*/
 	function deserializeFilter(query) {
 		const result = {};
@@ -2450,9 +2569,9 @@
 			const inner = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
 			return `${cond.type}(${inner})`;
 		}
-		const restOp = _rebasepro_types.CANONICAL_TO_REST[cond.operator] || "eq";
+		const restOp = CANONICAL_OP_LOOKUP[cond.operator] ?? "eq";
 		if (Array.isArray(cond.value)) {
-			const items = cond.value.map(stringifyValue).join(",");
+			const items = cond.value.map((v) => escapeListItem(stringifyValue(v))).join(",");
 			return `${cond.column}.${restOp}.(${items})`;
 		}
 		return `${cond.column}.${restOp}.${stringifyValue(cond.value)}`;
@@ -2500,99 +2619,115 @@
 		if (secondDot === -1) return {
 			column,
 			operator: "==",
-			value: coerceValue(rest)
+			value: rest
 		};
 		const opStr = rest.substring(0, secondDot);
-		let valueStr = rest.substring(secondDot + 1);
+		const valueStr = rest.substring(secondDot + 1);
 		const operator = (0, _rebasepro_types.toCanonicalOp)(opStr) ?? "==";
 		if (valueStr.startsWith("(") && valueStr.endsWith(")")) return {
 			column,
 			operator,
-			value: valueStr.slice(1, -1).split(",").map((s) => coerceValue(s.trim()))
+			value: splitListItems(valueStr.slice(1, -1))
 		};
 		return {
 			column,
 			operator,
-			value: coerceValue(valueStr)
+			value: valueStr
 		};
 	}
 	//#endregion
 	//#region src/data/buildRebaseData.ts
 	/**
-	* Parse an orderBy string like "created_at:desc" into [field, direction].
+	* Convert a flat REST record (e.g. from RestFetchService) to Entity<M> format.
+	* Mirrors the client SDK's rowToEntity conversion.
 	*/
-	function parseOrderBy(orderBy) {
-		if (!orderBy) return void 0;
-		const parts = orderBy.split(":");
-		return [parts[0], parts[1] || "asc"];
+	function rowToEntity(row, slug) {
+		return {
+			id: row.id,
+			path: slug,
+			values: row
+		};
 	}
 	function createDriverAccessor(driver, slug) {
 		const accessor = {
 			async find(params) {
-				const orderParsed = parseOrderBy(params?.orderBy);
 				const filter = params?.where ? deserializeFilter(params.where) : void 0;
-				const entities = await driver.fetchCollection({
+				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, {
+					filter,
+					limit: params?.limit,
+					offset: params?.offset,
+					orderBy: params?.orderBy?.[0],
+					order: params?.orderBy?.[1],
+					searchString: params?.searchString
+				}, params.include) : await driver.fetchCollection({
 					path: slug,
 					limit: params?.limit,
 					offset: params?.offset,
 					filter,
-					orderBy: orderParsed?.[0],
-					order: orderParsed?.[1],
+					orderBy: params?.orderBy?.[0],
+					order: params?.orderBy?.[1],
 					searchString: params?.searchString
 				});
-				const limit = params?.limit ?? 20;
-				const offset = params?.offset ?? 0;
+				let total = rows.length + offset;
+				let hasMore = rows.length >= limit;
+				if (driver.count) {
+					total = await driver.count({
+						path: slug,
+						filter
+					});
+					hasMore = offset + rows.length < total;
+				}
 				return {
-					data: entities,
+					data: rows.map((row) => rowToEntity(row, slug)),
 					meta: {
-						total: entities.length,
+						total,
 						limit,
 						offset,
-						hasMore: entities.length >= limit
+						hasMore
 					}
 				};
 			},
 			async findById(id) {
-				return driver.fetchEntity({
+				const row = await driver.fetchOne({
 					path: slug,
-					entityId: id
+					id
 				});
+				return row ? rowToEntity(row, slug) : void 0;
 			},
 			async create(data, id) {
-				return driver.saveEntity({
+				return rowToEntity(await driver.save({
 					path: slug,
 					values: data,
-					entityId: id,
+					id,
 					status: "new"
-				});
+				}), slug);
 			},
 			async update(id, data) {
-				return driver.saveEntity({
+				return rowToEntity(await driver.save({
 					path: slug,
 					values: data,
-					entityId: id,
+					id,
 					status: "existing"
-				});
+				}), slug);
 			},
 			async delete(id) {
-				return driver.deleteEntity({ entity: {
+				return driver.delete({ row: {
 					id,
 					path: slug,
 					values: {}
 				} });
 			},
-			deleteAll: driver.deleteAll ? async () => {
-				return driver.deleteAll(slug);
-			} : void 0,
-			count: driver.countEntities ? async (params) => {
+			count: driver.count ? async (params) => {
 				const filter = params?.where ? deserializeFilter(params.where) : void 0;
-				return driver.countEntities({
+				return driver.count({
 					path: slug,
 					filter
 				});
 			} : void 0,
 			listen: driver.listenCollection ? (params, onUpdate, onError) => {
-				const orderParsed = parseOrderBy(params?.orderBy);
 				const limit = params?.limit ?? 20;
 				const offset = params?.offset ?? 0;
 				return driver.listenCollection({
@@ -2600,12 +2735,12 @@
 					limit: params?.limit,
 					offset: params?.offset,
 					filter: params?.where,
-					orderBy: orderParsed?.[0],
-					order: orderParsed?.[1],
+					orderBy: params?.orderBy?.[0],
+					order: params?.orderBy?.[1],
 					searchString: params?.searchString,
 					onUpdate: (entities) => {
 						onUpdate({
-							data: entities,
+							data: entities.map((row) => rowToEntity(row, slug)),
 							meta: {
 								total: entities.length,
 								limit,
@@ -2617,11 +2752,11 @@
 					onError
 				});
 			} : void 0,
-			listenById: driver.listenEntity ? (id, onUpdate, onError) => {
-				return driver.listenEntity({
+			listenById: driver.listenOne ? (id, onUpdate, onError) => {
+				return driver.listenOne({
 					path: slug,
-					entityId: id,
-					onUpdate: (entity) => onUpdate(entity ?? void 0),
+					id,
+					onUpdate: (entity) => onUpdate(entity ? rowToEntity(entity, slug) : void 0),
 					onError
 				});
 			} : void 0,
@@ -2658,7 +2793,7 @@
 	* @example
 	* const data = buildRebaseData(driver);
 	* await data.products.create({ name: "Camera", price: 299 });
-	* const { data: items } = await data.products.find({ where: { status: "eq.published" } });
+	* const { data: items } = await data.products.find({ where: { status: ["==", "published"] } });
 	*/
 	function buildRebaseData(driver) {
 		const cache = /* @__PURE__ */ new Map();
@@ -2677,6 +2812,230 @@
 			return getAccessor((0, _rebasepro_utils.toSnakeCase)(prop));
 		} });
 	}
+	/**
+	* Unwrap a Entity into a flat row. `rowToEntity` stores the whole flat row
+	* (id included) under `.values`, so this is just that payload.
+	*/
+	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) {
+				this.params.logical = columnOrCondition;
+				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;
+		}
+		orderBy(column, direction = "asc") {
+			this.params.orderBy = [column, direction];
+			return this;
+		}
+		limit(count) {
+			this.params.limit = count;
+			return this;
+		}
+		offset(count) {
+			this.params.offset = count;
+			return this;
+		}
+		search(searchString) {
+			this.params.searchString = searchString;
+			return this;
+		}
+		include(...relations) {
+			this.params.include = relations;
+			return this;
+		}
+		async find() {
+			return this.client.find(this.params);
+		}
+		async count() {
+			return this.client.count ? this.client.count(this.params) : 0;
+		}
+		listen(onUpdate, onError) {
+			if (!this.client.listen) throw new Error("Listen is only available when the driver supports realtime.");
+			return this.client.listen(this.params, onUpdate, onError);
+		}
+	};
+	/**
+	* 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) {
+		const client = {
+			async find(params) {
+				const res = await snap.find(params);
+				return {
+					data: res.data.map(entityToRow),
+					meta: res.meta
+				};
+			},
+			async findById(id) {
+				const s = await snap.findById(id);
+				return s ? entityToRow(s) : void 0;
+			},
+			async create(data, id) {
+				return entityToRow(await snap.create(data, id));
+			},
+			async update(id, data) {
+				return entityToRow(await snap.update(id, data));
+			},
+			delete(id) {
+				return snap.delete(id);
+			},
+			count: snap.count ? (params) => snap.count(params) : void 0,
+			listen: snap.listen ? (params, onUpdate, onError) => snap.listen(params, (res) => onUpdate({
+				data: res.data.map(entityToRow),
+				meta: res.meta
+			}), onError) : void 0,
+			listenById: snap.listenById ? (id, onUpdate, onError) => snap.listenById(id, (s) => onUpdate(s ? entityToRow(s) : void 0), onError) : void 0,
+			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) => new SdkQueryBuilder(client).orderBy(column, direction),
+			limit: (count) => new SdkQueryBuilder(client).limit(count),
+			offset: (count) => new SdkQueryBuilder(client).offset(count),
+			search: (searchString) => new SdkQueryBuilder(client).search(searchString),
+			include: (...relations) => new SdkQueryBuilder(client).include(...relations)
+		};
+		return client;
+	}
+	/**
+	* 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.
+	*/
+	function toEntityAccessor(sdk, slug) {
+		const accessor = {
+			async find(params) {
+				const res = await sdk.find(params);
+				return {
+					data: res.data.map((row) => rowToEntity(row, slug)),
+					meta: res.meta
+				};
+			},
+			async findById(id) {
+				const row = await sdk.findById(id);
+				return row ? rowToEntity(row, slug) : void 0;
+			},
+			async create(data, id) {
+				return rowToEntity(await sdk.create(data, id), slug);
+			},
+			async update(id, data) {
+				const row = await sdk.update(id, data);
+				if (!row) throw new Error(`Update returned no data for id ${id}`);
+				return rowToEntity(row, slug);
+			},
+			delete(id) {
+				return sdk.delete(id);
+			},
+			count: sdk.count ? (params) => sdk.count(params) : void 0,
+			listen: sdk.listen ? (params, onUpdate, onError) => sdk.listen(params, (res) => onUpdate({
+				data: res.data.map((row) => rowToEntity(row, slug)),
+				meta: res.meta
+			}), onError) : void 0,
+			listenById: sdk.listenById ? (id, onUpdate, onError) => sdk.listenById(id, (row) => onUpdate(row ? rowToEntity(row, slug) : 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, 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),
+			include: (...relations) => new QueryBuilder(accessor).include(...relations)
+		};
+		return accessor;
+	}
+	/**
+	* Wrap a flat {@link RebaseSdkData} into a Entity-shaped {@link RebaseData}.
+	*
+	* This is the **CMS 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
+	* `id`.
+	*/
+	function wrapAsEntityData(sdkData) {
+		const cache = /* @__PURE__ */ new Map();
+		function getAccessor(slug) {
+			let accessor = cache.get(slug);
+			if (!accessor) {
+				accessor = toEntityAccessor(sdkData.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((0, _rebasepro_utils.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) {
+		const cache = /* @__PURE__ */ new Map();
+		function getAccessor(slug) {
+			let accessor = cache.get(slug);
+			if (!accessor) {
+				accessor = toSdkCollectionClient(entityData.collection(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((0, _rebasepro_utils.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.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).
+	*/
+	function buildSdkData(driver) {
+		return wrapAsSdkData(buildRebaseData(driver));
+	}
 	//#endregion
 	//#region src/data/buildRoutedRebaseData.ts
 	/**
@@ -2721,6 +3080,57 @@
 		} });
 	}
 	//#endregion
+	//#region src/data/sort-dialect.ts
+	/**
+	* Sort-order wire codec.
+	*
+	* This is the ONLY module that knows about the colon-delimited wire format
+	* (`"field:direction"`) used in HTTP query parameters.
+	* Everything else speaks {@link OrderByTuple} exclusively.
+	*
+	* Mirrors the filter architecture in `filter-dialect.ts`.
+	*
+	* @module
+	*/
+	/**
+	* Serialize an {@link OrderByTuple} to the wire format `"field:direction"`.
+	*
+	* **Runtime tolerance:** if the input is already a well-formed wire string
+	* (from an untyped JS caller), it is returned unchanged.
+	* This is undocumented tolerance, not public API — don't rely on it.
+	*
+	* @param orderBy - A canonical `[field, direction]` tuple, or at runtime
+	*   possibly a pre-serialized string (undocumented tolerance).
+	* @returns The wire-format string, or `undefined` if the input is falsy.
+	*
+	* @remarks
+	* Field names containing `:` are representable in the tuple form but
+	* **not** on the wire — this is an inherent limitation of the colon-delimited
+	* encoding and is not resolved here.
+	*/
+	function serializeOrderBy(orderBy) {
+		if (!orderBy) return void 0;
+		if (typeof orderBy === "string") return orderBy;
+		return `${orderBy[0]}:${orderBy[1]}`;
+	}
+	/**
+	* Deserialize a wire-format `"field:direction"` string into an {@link OrderByTuple}.
+	*
+	* Lenient parsing (matches existing server behaviour):
+	* - Bare field name (no colon): `"name"` → `["name", "asc"]`
+	* - Unknown direction: `"name:foo"` → `["name", "asc"]`
+	* - Empty / falsy input: → `undefined`
+	*
+	* @param raw - The wire-format string from an HTTP query parameter.
+	* @returns The canonical tuple, or `undefined` if the input is empty/falsy.
+	*/
+	function deserializeOrderBy(raw) {
+		if (!raw) return void 0;
+		const idx = raw.indexOf(":");
+		if (idx === -1) return [raw, "asc"];
+		return [raw.slice(0, idx), raw.slice(idx + 1) === "desc" ? "desc" : "asc"];
+	}
+	//#endregion
 	//#region src/table-classification.ts
 	/** Schemas that are always considered Rebase-internal. */
 	var REBASE_INTERNAL_SCHEMAS = ["rebase", "auth"];
@@ -2808,18 +3218,13 @@
 	exports.addInitialSlash = addInitialSlash;
 	exports.and = and;
 	exports.applyPropertyConditions = applyPropertyConditions;
-	exports.buildAdditionalFieldDelegate = buildAdditionalFieldDelegate;
 	exports.buildCollection = buildCollection;
 	exports.buildConditionContext = buildConditionContext;
-	exports.buildEntityCallbacks = buildEntityCallbacks;
-	exports.buildEnum = buildEnum;
-	exports.buildEnumValueConfig = buildEnumValueConfig;
-	exports.buildProperties = buildProperties;
-	exports.buildPropertiesOrBuilder = buildPropertiesOrBuilder;
 	exports.buildProperty = buildProperty;
 	exports.buildPropertyCallbacks = buildPropertyCallbacks;
 	exports.buildRebaseData = buildRebaseData;
 	exports.buildRoutedRebaseData = buildRoutedRebaseData;
+	exports.buildSdkData = buildSdkData;
 	exports.canCreateEntity = canCreateEntity;
 	exports.canDeleteEntity = canDeleteEntity;
 	exports.canEditEntity = canEditEntity;
@@ -2834,6 +3239,7 @@
 	exports.defineCollection = defineCollection;
 	exports.deserializeFilter = deserializeFilter;
 	exports.deserializeLogicalCondition = deserializeLogicalCondition;
+	exports.deserializeOrderBy = deserializeOrderBy;
 	exports.detectJunctionTables = detectJunctionTables;
 	exports.enumToObjectEntries = enumToObjectEntries;
 	exports.evaluateCondition = evaluateCondition;
@@ -2877,6 +3283,7 @@
 	exports.resolveDataSource = resolveDataSource;
 	exports.resolveDefaultSelectedView = resolveDefaultSelectedView;
 	exports.resolveEnumValues = resolveEnumValues;
+	exports.resolveFilterOperators = resolveFilterOperators;
 	exports.resolveProperties = resolveProperties;
 	exports.resolveProperty = resolveProperty;
 	exports.resolvePropertyEnum = resolvePropertyEnum;
@@ -2891,11 +3298,14 @@
 	exports.segmentsToStrippedPath = segmentsToStrippedPath;
 	exports.serializeFilter = serializeFilter;
 	exports.serializeLogicalCondition = serializeLogicalCondition;
+	exports.serializeOrderBy = serializeOrderBy;
 	exports.sortProperties = sortProperties;
 	exports.stripCollectionPath = stripCollectionPath;
 	exports.traverseValueProperty = traverseValueProperty;
 	exports.traverseValuesProperties = traverseValuesProperties;
 	exports.updateDateAutoValues = updateDateAutoValues;
+	exports.wrapAsEntityData = wrapAsEntityData;
+	exports.wrapAsSdkData = wrapAsSdkData;
 });
 
 //# sourceMappingURL=index.umd.js.map