@rebasepro/common 0.8.0 → 0.9.0

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, policy, toCanonicalOp } from "@rebasepro/types";
+import { ALL_WHERE_FILTER_OPS, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, policy, toCanonicalOp } from "@rebasepro/types";
 import { deepClone, generateForeignKeyName, getIn, isDefaultFieldConfigId, mergeDeep, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
@@ -54,7 +54,7 @@ function getDefaultValueFortype(type) {
 	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 }) {
@@ -66,7 +66,7 @@ function updateDateAutoValues({ inputValues, properties, status, timestampNowVal
 	}) ?? {};
 }
 /**
-* 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
@@ -236,7 +236,7 @@ function getLocalChangesBackup(collection) {
 	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
@@ -780,22 +780,56 @@ function withRoles(base, rule) {
 * {@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) : 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: "!=",
@@ -804,14 +838,18 @@ var COMPARE_SQL = {
 	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;
@@ -854,6 +892,7 @@ function evaluatePolicy(expr, ctx) {
 			return expr.roles.every((r) => r === "public" || userRoles.includes(r));
 		}
 		case "authenticated": return ctx.uid != null;
+		case "existsIn": return "unknown";
 		case "raw": return "unknown";
 	}
 }
@@ -891,6 +930,7 @@ function resolveOperand(operand, ctx) {
 				known: true,
 				value: ctx.entity.values[operand.name]
 			};
+		case "outerField": return { known: false };
 	}
 }
 function evaluateCompare(op, left, right, ctx) {
@@ -1102,7 +1142,7 @@ function resolveCollectionPathIds(path, allCollections) {
 			} 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);
@@ -1258,9 +1298,12 @@ function getParentReferencesFromPath(props) {
 //#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) {
@@ -1274,68 +1317,16 @@ function defineCollection(collection) {
 	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
 /**
@@ -1471,16 +1462,17 @@ async function processProperties(properties, values, previousValues, propsContex
 }
 /**
 * 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) => {
@@ -1667,6 +1659,84 @@ function applyEnumConditions(enumValues, conditions, context) {
 	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(getDataSourceCapabilities(engine).filterOperators ?? 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.
@@ -1745,7 +1815,7 @@ var CollectionRegistry = class {
 	rawCollectionsBySlug = /* @__PURE__ */ new Map();
 	rawRootCollections = [];
 	cachedRawCollectionsList = null;
-	lastRawInputSnapshot = null;
+	lastRawInputEntity = null;
 	constructor(collections, dataSources) {
 		if (dataSources) this.dataSources = dataSources;
 		if (collections) this.registerMultiple(collections);
@@ -1775,12 +1845,12 @@ var CollectionRegistry = class {
 	* 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) => removeFunctions(c));
-		if (this.lastRawInputSnapshot && deepEqual(this.lastRawInputSnapshot, rawSnapshot)) return false;
+		const rawEntity = collections.map((c) => removeFunctions(c));
+		if (this.lastRawInputEntity && deepEqual(this.lastRawInputEntity, rawEntity)) return false;
 		this.reset();
 		collections.forEach((c) => {
 			if (c.slug) this.collectionsBySlug.set(c.slug, c);
@@ -1804,7 +1874,7 @@ var CollectionRegistry = class {
 				this._registerRecursively(this.normalizeCollection({ ...subCollection }), deepClone(subCollection));
 			});
 		});
-		this.lastRawInputSnapshot = rawSnapshot;
+		this.lastRawInputEntity = rawEntity;
 		return true;
 	}
 	register(collection, rawCollection) {
@@ -2224,7 +2294,7 @@ var QueryBuilder = class {
 	* client.collection('users').orderBy('createdAt', 'desc').find()
 	*/
 	orderBy(column, direction = "asc") {
-		this.params.orderBy = `${column}:${direction}`;
+		this.params.orderBy = [column, direction];
 		return this;
 	}
 	/**
@@ -2287,32 +2357,69 @@ var QueryBuilder = class {
 * 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 = REST_TO_CANONICAL;
+var CANONICAL_OP_LOOKUP = 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"
@@ -2320,22 +2427,20 @@ function stringifyValue(value) {
 * serializeTuple([">=", 18])                 // "gte.18"
 */
 function serializeTuple(tuple) {
-	if (typeof tuple === "string") {
-		if (tuple.includes(".")) {
-			const dotIndex = tuple.indexOf(".");
-			if (REST_TO_CANONICAL[tuple.substring(0, dotIndex)]) return tuple;
-		}
-		return tuple;
-	}
-	if (!Array.isArray(tuple) || tuple.length !== 2 || typeof tuple[0] !== "string" || !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 = 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(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).
 *
@@ -2345,11 +2450,19 @@ function serializeTuple(tuple) {
 *
 * 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);
 	}
@@ -2358,18 +2471,24 @@ function serializeFilter(filter) {
 /**
 * 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 = 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 (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`.
@@ -2382,7 +2501,7 @@ function deserializeSingle(raw) {
 * // → { status: ["==", "active"] }
 *
 * deserializeFilter({ age: ["gte.18", "lt.65"] })
-* // → { age: [[">=", 18], ["<", 65]] }
+* // → { age: [[">=", "18"], ["<", "65"]] }
 */
 function deserializeFilter(query) {
 	const result = {};
@@ -2421,9 +2540,9 @@ function serializeLogicalCondition(cond) {
 		const inner = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
 		return `${cond.type}(${inner})`;
 	}
-	const restOp = 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)}`;
@@ -2471,99 +2590,115 @@ function deserializeLogicalCondition(str) {
 	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 = 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({
@@ -2571,12 +2706,12 @@ function createDriverAccessor(driver, slug) {
 				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,
@@ -2588,11 +2723,11 @@ function createDriverAccessor(driver, slug) {
 				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,
@@ -2629,7 +2764,7 @@ function createDriverAccessor(driver, slug) {
 * @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();
@@ -2648,6 +2783,230 @@ function buildRebaseData(driver) {
 		return getAccessor(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(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(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
 /**
@@ -2692,6 +3051,57 @@ function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
 	} });
 }
 //#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"];
@@ -2768,6 +3178,6 @@ async function detectJunctionTables(executeSql) {
 	return junctionTables;
 }
 //#endregion
-export { COLLECTION_PATH_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, addInitialSlash, and, applyPropertyConditions, buildAdditionalFieldDelegate, buildCollection, buildConditionContext, buildEntityCallbacks, buildEnum, buildEnumValueConfig, buildProperties, buildPropertiesOrBuilder, buildProperty, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, cond, createDataSourceRegistry, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, detectJunctionTables, enumToObjectEntries, evaluateCondition, evaluatePolicy, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getCollectionBySlugWithin, getCollectionPathsCombinations, getColumnName, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEntityImagePreviewPropertyKey, getEnumVarName, getLabelOrConfigFrom, getLastSegment, getLocalChangesBackup, getNavigationEntriesFromPath, getParentReferencesFromPath, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isHidden, isPropertyBuilder, isReadOnly, isRebaseInternalTable, normalizeToEntityRelation, or, policyToPostgres, registerConditionOperations, removeInitialAndTrailingSlashes, removeInitialSlash, removeTrailingSlash, resolveArrayProperties, resolveCollectionPathIds, resolveCollectionRelations, resolveDataSource, resolveDefaultSelectedView, resolveEnumValues, resolveProperties, resolveProperty, resolvePropertyEnum, resolvePropertyRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, sanitizeData, sanitizeRelation, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, sortProperties, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues };
+export { COLLECTION_PATH_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, addInitialSlash, and, applyPropertyConditions, buildCollection, buildConditionContext, buildProperty, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, cond, createDataSourceRegistry, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, enumToObjectEntries, evaluateCondition, evaluatePolicy, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getCollectionBySlugWithin, getCollectionPathsCombinations, getColumnName, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEntityImagePreviewPropertyKey, getEnumVarName, getLabelOrConfigFrom, getLastSegment, getLocalChangesBackup, getNavigationEntriesFromPath, getParentReferencesFromPath, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isHidden, isPropertyBuilder, isReadOnly, isRebaseInternalTable, normalizeToEntityRelation, or, policyToPostgres, registerConditionOperations, removeInitialAndTrailingSlashes, removeInitialSlash, removeTrailingSlash, resolveArrayProperties, resolveCollectionPathIds, resolveCollectionRelations, resolveDataSource, resolveDefaultSelectedView, resolveEnumValues, resolveFilterOperators, resolveProperties, resolveProperty, resolvePropertyEnum, resolvePropertyRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, sanitizeData, sanitizeRelation, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
 
 //# sourceMappingURL=index.es.js.map