@rebasepro/common 0.13.0 → 0.13.1-canary.g394d868

package/dist/data/filter-dialect.d.ts

@@ -72,4 +72,18 @@ export declare function serializeLogicalCondition(cond: LogicalCondition | Filte
  * deserializeLogicalCondition("or(status.eq.active,age.gte.18)")
  * // → { type: "or", conditions: [...] }
  */
-export declare function deserializeLogicalCondition(str: string): LogicalCondition | FilterCondition;
+/**
+ * How deeply `or(...)`/`and(...)` groups may nest.
+ *
+ * This parser recurses once per level, on a value that arrives in a query
+ * string. Unbounded, twenty thousand levels reached `RangeError: Maximum call
+ * stack size exceeded`, which a caller sees as a 500 about the call stack
+ * rather than a 400 about their filter. Node's 16 KB header cap keeps a GET
+ * below that in practice, but "the HTTP layer happens to stop it" is not a
+ * bound this parser should rely on.
+ *
+ * Thirty-two is far past anything a real filter expresses; the deepest in this
+ * repository's own tests is three.
+ */
+export declare const MAX_LOGICAL_NESTING_DEPTH = 32;
+export declare function deserializeLogicalCondition(str: string, nesting?: number): LogicalCondition | FilterCondition;

package/dist/data/paginate.d.ts

@@ -45,6 +45,26 @@ export declare class RebasePaginationError extends Error {
 }
 /** The one thing a transport has to provide to be paginated. */
 export type PageFinder<M extends Record<string, unknown> = Record<string, unknown>> = (params: FindParams<M>) => Promise<FindResult<M>>;
+/**
+ * Resolve `limit`/`offset`/`page` into the window a read will actually use.
+ *
+ * Lives here, next to the walk, for the reason at the top of this file: every
+ * transport has to mean the same thing by "page two". Four of them did not —
+ * the REST layer strode by {@link DEFAULT_LIST_LIMIT}, the local-first
+ * evaluator by {@link DEFAULT_PAGE_SIZE}, the in-process accessor by 20, and
+ * the published type documented a fourth number. Pages that overlap or skip
+ * rows are the mildest of those outcomes.
+ *
+ * `page` wins over `offset`, as {@link FindParams} documents. `driverOffset`
+ * is the value to hand a driver: it stays `undefined` when the caller named no
+ * offset, because keyset pagination seeks with a `where` clause and must not
+ * look like it is paging by offset.
+ */
+export declare function resolveFindWindow(params?: Pick<FindParams, "limit" | "offset" | "page">): {
+    limit: number;
+    offset: number;
+    driverOffset: number | undefined;
+};
 /**
  * Walk every row a query matches, yielding one row at a time and fetching the
  * next page only when the consumer asks for it.

package/dist/data/resolveDataSource.d.ts

@@ -41,3 +41,39 @@ export declare function createDataSourceRegistry(definitions?: DataSourceDefinit
  * @param registry   optional registry of declared data sources
  */
 export declare function resolveDataSource(collection: DataSourceResolvable | undefined, registry?: DataSourceRegistry): ResolvedDataSource;
+/**
+ * Does a SQL toolchain own this collection's storage?
+ *
+ * "Owns the storage" means: something generates a table for it, pushes that
+ * table to a database, plans its RLS policies, and reports it as drifted when
+ * the two disagree. That is true of a Postgres collection and false of a
+ * Firestore or MongoDB one, whose documents live in a store Rebase never
+ * migrates — and the two were never told apart. Every stage of the SQL
+ * toolchain took "the collections" to mean *all* of them, so a Firestore
+ * collection declared next to the Postgres ones got a `pgTable` in the
+ * generated schema, a `CREATE TABLE` at boot, RLS policies, and a place in the
+ * `db push` include list — where its name shielding a same-named real table
+ * from Atlas's exclude list is the one that can lose data.
+ *
+ * The answer is the resolved engine's {@link DataSourceCapabilities}, not a
+ * name check: an engine registered through `registerDataSourceCapabilities`
+ * gets the same treatment as the built-in ones.
+ *
+ * Deliberately answers **true** for an engine nobody has heard of. Build-time
+ * tooling (the CLI, the schema generator) has no data-source registry to
+ * resolve a `dataSource` key against, so an unknown key resolves to an unknown
+ * engine — and the cost of the two mistakes is not symmetric. Wrongly
+ * including a collection generates a table nothing writes to; wrongly excluding
+ * one silently stops generating a table the app is serving from. Declare
+ * `engine` on a collection that is not SQL-backed and this is exact.
+ */
+export declare function isRelationalCollection(collection: DataSourceResolvable | undefined, registry?: DataSourceRegistry): boolean;
+/**
+ * The subset of `collections` a SQL toolchain owns — see
+ * {@link isRelationalCollection}.
+ *
+ * Every stage that generates SQL from collections starts by calling this, so
+ * the rule lives in one place rather than being re-decided per generator. It
+ * keeps the input order.
+ */
+export declare function relationalCollections<C extends DataSourceResolvable>(collections: readonly C[], registry?: DataSourceRegistry): C[];

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, isAnonymousUid, isManyToMany, isPostgresCollectionConfig, isRelationalCollectionConfig, policy, toCanonicalOp } from "@rebasepro/types";
+import { ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, DEFAULT_LIST_LIMIT, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, isAnonymousUid, isManyToMany, isPostgresCollectionConfig, isRelationalCollectionConfig, policy, toCanonicalOp } from "@rebasepro/types";
 import { deepClone, generateForeignKeyName, getIn, getPolicyNamesForRules, getPolicyOperations, isDefaultFieldConfigId, mergeDeep, prettifyIdentifier, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
@@ -89,10 +89,21 @@ function getRelationFrom(entity) {
 * have `id` and `path` fields — these are relation-shaped objects from
 * edge cases in the data pipeline (REST fallback, stale cache, custom data source).
 *
+* When `targetPath` is given, also accepts a bare id. A relation column is a
+* foreign key, and the REST layer returns it as the scalar it is; only some
+* fetch paths hydrate it into an object. Which form a caller sees therefore
+* depends on how the row was loaded, and a caller that only accepted objects
+* reported half of its own data as a type error. The declared target is the
+* missing half: with it, an id is a relation that has not been fetched yet.
+*
 * Returns null if the value cannot be coerced.
 */
-function normalizeToEntityRelation(value, propertyType) {
+function normalizeToEntityRelation(value, propertyType, targetPath) {
 	if (value instanceof EntityRelation) return value;
+	if (targetPath && (typeof value === "string" || typeof value === "number")) {
+		if (value === "") return null;
+		return new EntityRelation(value, targetPath);
+	}
 	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
 	const obj = value;
 	if (!(obj.__type === "relation" || obj.__type === "reference" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation() || typeof obj.isEntityReference === "function" && obj.isEntityReference() || propertyType === "relation" && typeof obj.id !== "undefined" && typeof obj.path === "string")) return null;
@@ -608,6 +619,33 @@ function resolveCollectionRelations(collection) {
 	_resolvedRelationsCache.set(collection, relations);
 	return relations;
 }
+/**
+* The path of the collection a relation property points at, derived from the
+* property alone.
+*
+* A preview holds a property and a value and no collection, so it cannot call
+* `resolveRelationProperty`. It does not need to: both forms that carry a
+* target — the stamped `resolvedRelation` and the inline `relation` — name it
+* directly. Only the third form, a relation declared by name in the
+* collection's `relations` array, is out of reach, and that one has no target
+* to read without the collection anyway.
+*
+* This is what lets a preview render a relation column that arrived as a bare
+* foreign key: the id says *which* row, the declared target says *which
+* collection*, and `RelationPreview` fetches the rest. Without it a scalar id
+* is indistinguishable from a value of the wrong type.
+*/
+function getRelationTargetPath(property) {
+	const stamped = property.resolvedRelation?.targetSlug;
+	if (stamped) return stamped;
+	const target = property.relation?.target;
+	if (typeof target !== "function") return void 0;
+	try {
+		return target()?.slug;
+	} catch (_e) {
+		return;
+	}
+}
 function getTableName(collection) {
 	if (isRelationalCollectionConfig(collection)) return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 	return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
@@ -882,6 +920,59 @@ function getEntityChildViews(collection) {
 	return views;
 }
 /**
+* Each of `collection`'s tabs paired with the property that declared it, when a
+* property declared it: child view key → property key.
+*
+* A many-relation can only be declared as a property — that is the documented
+* and only mechanism — and {@link getEntityChildViews} promotes it to a tab. So
+* one declaration reaches the panel twice, and neither surface knew about the
+* other. The form rendered a relation picker beside the tab, and the collection
+* table rendered *two* columns under one heading: the relation's own column,
+* showing the child rows, and a jump-to-tab button carrying the same name.
+*
+* The pairing is what lets each surface decide which half is redundant, and it
+* has to be a pairing rather than two sets because the two keys differ whenever
+* a relation is named. The match is on the resolved `relationName` — the
+* identity `getEntityChildViews` itself dedupes on — so a relation declared in
+* `relations` and pointed at by a differently-named property is recognised too.
+*
+* A relation with no property of its own is absent here, which is the point: it
+* has exactly one surface already, and nothing to weigh it against.
+*
+* Only top-level properties: a relation nested inside a `map` gets no tab.
+*/
+function getChildViewDeclaringProperties(collection) {
+	const pairs = /* @__PURE__ */ new Map();
+	const relationProperties = Object.entries(collection.properties ?? {}).filter(([, property]) => property?.type === "relation");
+	if (relationProperties.length === 0) return pairs;
+	const relationViews = getEntityChildViews(collection).filter((view) => view.source.kind === "relation");
+	if (relationViews.length === 0) return pairs;
+	const resolvedRelations = resolveCollectionRelations(collection);
+	const identityOf = (relationKey) => resolvedRelations[relationKey]?.relationName ?? relationKey;
+	const declaringPropertyByIdentity = /* @__PURE__ */ new Map();
+	for (const [propertyKey, property] of relationProperties) {
+		const relation = property.resolvedRelation ?? resolvedRelations[propertyKey];
+		if (relation?.cardinality !== "many") continue;
+		const identity = relation.relationName ?? propertyKey;
+		if (!declaringPropertyByIdentity.has(identity)) declaringPropertyByIdentity.set(identity, propertyKey);
+	}
+	for (const view of relationViews) {
+		const propertyKey = declaringPropertyByIdentity.get(identityOf(view.source.relationKey));
+		if (propertyKey) pairs.set(view.key, propertyKey);
+	}
+	return pairs;
+}
+/**
+* The property keys of `collection` whose relation is already one of its tabs.
+*
+* What a form asks: the tab is the treatment for a list of child rows, so the
+* picker beside it is the redundant half. See
+* {@link getChildViewDeclaringProperties}.
+*/
+function getChildViewRelationPropertyKeys(collection) {
+	return new Set(getChildViewDeclaringProperties(collection).values());
+}
+/**
 * The child views of `collection` as bare collections.
 *
 * The flattened view of {@link getEntityChildViews}, for navigation code that
@@ -1996,9 +2087,14 @@ function registerConditionOperations() {
 	operationsRegistered = true;
 }
 /**
-* Evaluate a JSON Logic rule against the given context.
+* Evaluate a condition against the given context.
+*
+* A condition may be stated as a literal instead of a rule — `hidden: true`
+* rather than `hidden: { "==": [1, 1] }` — and a literal is already its own
+* answer, so it is returned rather than handed to the evaluator.
 */
 function evaluateCondition(rule, context) {
+	if (typeof rule === "boolean") return rule;
 	registerConditionOperations();
 	return jsonLogic.apply(rule, context);
 }
@@ -2359,6 +2455,46 @@ function resolveDataSource(collection, registry) {
 		capabilities: getDataSourceCapabilities(engine)
 	};
 }
+/**
+* Does a SQL toolchain own this collection's storage?
+*
+* "Owns the storage" means: something generates a table for it, pushes that
+* table to a database, plans its RLS policies, and reports it as drifted when
+* the two disagree. That is true of a Postgres collection and false of a
+* Firestore or MongoDB one, whose documents live in a store Rebase never
+* migrates — and the two were never told apart. Every stage of the SQL
+* toolchain took "the collections" to mean *all* of them, so a Firestore
+* collection declared next to the Postgres ones got a `pgTable` in the
+* generated schema, a `CREATE TABLE` at boot, RLS policies, and a place in the
+* `db push` include list — where its name shielding a same-named real table
+* from Atlas's exclude list is the one that can lose data.
+*
+* The answer is the resolved engine's {@link DataSourceCapabilities}, not a
+* name check: an engine registered through `registerDataSourceCapabilities`
+* gets the same treatment as the built-in ones.
+*
+* Deliberately answers **true** for an engine nobody has heard of. Build-time
+* tooling (the CLI, the schema generator) has no data-source registry to
+* resolve a `dataSource` key against, so an unknown key resolves to an unknown
+* engine — and the cost of the two mistakes is not symmetric. Wrongly
+* including a collection generates a table nothing writes to; wrongly excluding
+* one silently stops generating a table the app is serving from. Declare
+* `engine` on a collection that is not SQL-backed and this is exact.
+*/
+function isRelationalCollection(collection, registry) {
+	return getDataSourceCapabilities(collection?.engine ?? (collection?.dataSource ? resolveDataSource(collection, registry).engine : void 0)).supportsRelations;
+}
+/**
+* The subset of `collections` a SQL toolchain owns — see
+* {@link isRelationalCollection}.
+*
+* Every stage that generates SQL from collections starts by calling this, so
+* the rule lives in one place rather than being re-decided per generator. It
+* keeps the input order.
+*/
+function relationalCollections(collections, registry) {
+	return collections.filter((collection) => isRelationalCollection(collection, registry));
+}
 //#endregion
 //#region src/collections/CollectionRegistry.ts
 var CollectionRegistry = class {
@@ -2861,6 +2997,30 @@ var RebasePaginationError = class RebasePaginationError extends Error {
 		Object.setPrototypeOf(this, RebasePaginationError.prototype);
 	}
 };
+/**
+* Resolve `limit`/`offset`/`page` into the window a read will actually use.
+*
+* Lives here, next to the walk, for the reason at the top of this file: every
+* transport has to mean the same thing by "page two". Four of them did not —
+* the REST layer strode by {@link DEFAULT_LIST_LIMIT}, the local-first
+* evaluator by {@link DEFAULT_PAGE_SIZE}, the in-process accessor by 20, and
+* the published type documented a fourth number. Pages that overlap or skip
+* rows are the mildest of those outcomes.
+*
+* `page` wins over `offset`, as {@link FindParams} documents. `driverOffset`
+* is the value to hand a driver: it stays `undefined` when the caller named no
+* offset, because keyset pagination seeks with a `where` clause and must not
+* look like it is paging by offset.
+*/
+function resolveFindWindow(params) {
+	const limit = params?.limit ?? DEFAULT_LIST_LIMIT;
+	const offset = params?.page != null ? Math.max(0, (params.page - 1) * limit) : params?.offset ?? 0;
+	return {
+		limit,
+		offset,
+		driverOffset: params?.page != null ? offset : params?.offset
+	};
+}
 function normalizePageSize(raw) {
 	if (raw === void 0 || !Number.isFinite(raw)) return 200;
 	return Math.max(1, Math.floor(raw));
@@ -3194,7 +3354,22 @@ function serializeLogicalCondition(cond) {
 * deserializeLogicalCondition("or(status.eq.active,age.gte.18)")
 * // → { type: "or", conditions: [...] }
 */
-function deserializeLogicalCondition(str) {
+/**
+* How deeply `or(...)`/`and(...)` groups may nest.
+*
+* This parser recurses once per level, on a value that arrives in a query
+* string. Unbounded, twenty thousand levels reached `RangeError: Maximum call
+* stack size exceeded`, which a caller sees as a 500 about the call stack
+* rather than a 400 about their filter. Node's 16 KB header cap keeps a GET
+* below that in practice, but "the HTTP layer happens to stop it" is not a
+* bound this parser should rely on.
+*
+* Thirty-two is far past anything a real filter expresses; the deepest in this
+* repository's own tests is three.
+*/
+var MAX_LOGICAL_NESTING_DEPTH = 32;
+function deserializeLogicalCondition(str, nesting = 0) {
+	if (nesting > 32) throw new Error(`Filter groups nest more than 32 levels deep. Flatten the condition — \`or(a,or(b,c))\` is \`or(a,b,c)\`.`);
 	const logicalMatch = str.match(/^(and|or)\((.+)\)$/);
 	if (logicalMatch) {
 		const type = logicalMatch[1];
@@ -3205,10 +3380,10 @@ function deserializeLogicalCondition(str) {
 		for (let i = 0; i < innerStr.length; i++) if (innerStr[i] === "(") depth++;
 		else if (innerStr[i] === ")") depth--;
 		else if (innerStr[i] === "," && depth === 0) {
-			conditions.push(deserializeLogicalCondition(innerStr.slice(start, i)));
+			conditions.push(deserializeLogicalCondition(innerStr.slice(start, i), nesting + 1));
 			start = i + 1;
 		}
-		conditions.push(deserializeLogicalCondition(innerStr.slice(start)));
+		conditions.push(deserializeLogicalCondition(innerStr.slice(start), nesting + 1));
 		return {
 			type,
 			conditions
@@ -3322,21 +3497,22 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 	const accessor = {
 		async find(params) {
 			const filter = params?.where ? deserializeFilter(params.where) : void 0;
-			const limit = params?.limit ?? 20;
-			const offset = params?.offset ?? 0;
+			const { limit, offset, driverOffset } = resolveFindWindow(params);
 			const fetchService = driver.restFetchService;
 			const rows = fetchService ? await fetchService.fetchCollectionForRest(slug, {
 				filter,
-				limit: params?.limit,
-				offset: params?.offset,
+				logical: params?.logical,
+				limit,
+				offset: driverOffset,
 				orderBy: params?.orderBy?.[0],
 				order: params?.orderBy?.[1],
 				searchString: params?.searchString
 			}, params?.include) : await driver.fetchCollection({
 				path: slug,
-				limit: params?.limit,
-				offset: params?.offset,
+				limit,
+				offset: driverOffset,
 				filter,
+				logical: params?.logical,
 				orderBy: params?.orderBy?.[0],
 				order: params?.orderBy?.[1],
 				searchString: params?.searchString
@@ -3346,7 +3522,9 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 			if (driver.count) {
 				total = await driver.count({
 					path: slug,
-					filter
+					filter,
+					logical: params?.logical,
+					searchString: params?.searchString
 				});
 				hasMore = offset + rows.length < total;
 			}
@@ -3398,22 +3576,39 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				values: {}
 			} });
 		},
+		updateMany: driver.updateMany ? async (updates) => {
+			return (await driver.updateMany({
+				path: slug,
+				updates: updates.map((u) => ({
+					id: u.id,
+					values: u.data
+				}))
+			})).map((row) => rowToEntity(row, slug, getPks()));
+		} : void 0,
+		deleteMany: driver.deleteMany ? async (ids) => {
+			await driver.deleteMany({
+				path: slug,
+				ids
+			});
+		} : void 0,
 		count: driver.count ? async (params) => {
 			const filter = params?.where ? deserializeFilter(params.where) : void 0;
 			return driver.count({
 				path: slug,
-				filter
+				filter,
+				logical: params?.logical,
+				searchString: params?.searchString
 			});
 		} : void 0,
 		listen: driver.listenCollection ? (params, onUpdate, onError) => {
-			const limit = params?.limit ?? 20;
-			const offset = params?.offset ?? 0;
+			const { limit, offset, driverOffset } = resolveFindWindow(params);
 			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
 			return driver.listenCollection({
 				path: slug,
-				limit: params?.limit,
-				offset: params?.offset,
+				limit,
+				offset: driverOffset,
 				filter: params?.where,
+				logical: params?.logical,
 				orderBy: params?.orderBy?.[0],
 				order: params?.orderBy?.[1],
 				searchString: params?.searchString,
@@ -3421,7 +3616,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 					onUpdate({
 						data: entities.map((row) => rowToEntity(normalize(row), slug, getPks())),
 						meta: {
-							total: entities.length,
+							total: offset + entities.length,
 							limit,
 							offset,
 							hasMore: entities.length >= limit
@@ -3598,9 +3793,24 @@ function toSdkCollectionClient(snap, slug = "collection") {
 		async update(id, data) {
 			return entityToRow(await snap.update(id, data));
 		},
+		async updateMany(updates) {
+			if (!Array.isArray(updates)) throw new TypeError("updateMany expects an array of { id, data } entries.");
+			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);
+		},
 		delete(id) {
 			return snap.delete(id);
 		},
+		async deleteMany(ids) {
+			if (!Array.isArray(ids)) throw new TypeError("deleteMany expects an array of ids.");
+			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) : void 0,
 		listen: snap.listen ? (params, onUpdate, onError) => snap.listen(params, (res) => onUpdate({
 			data: res.data.map(entityToRow),
@@ -3623,7 +3833,7 @@ function toSdkCollectionClient(snap, slug = "collection") {
 /**
 * 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 admin renders.
+* `{ id, path, values }` view-model the admin panel renders.
 */
 function toEntityAccessor(sdk, slug, getPks = () => []) {
 	const accessor = {
@@ -3906,6 +4116,6 @@ async function detectJunctionTables(executeSql) {
 	return junctionTables;
 }
 //#endregion
-export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_FIND_ALL_MAX_ROWS, DEFAULT_MAX_PAGES, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, DEFAULT_PAGE_SIZE, DEFAULT_STRING_COLUMN_LENGTH, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, RebasePaginationError, and, buildCollectionFromTableMetadata, buildCompositeId, buildConditionContext, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, collectAllPages, cond, createDataSourceRegistry, createPaginationHelpers, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEntityChildViews, getEnumVarName, getGeneratedPolicyNames, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isAddressableId, isJunctionBackedRelation, isPropertyBuilder, isRebaseInternalTable, normalizeEmail, normalizeToEntityRelation, or, paginateFind, parseIdValues, policyToPostgres, registerConditionOperations, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolveRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, resolveStringColumnLength, sanitizeData, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, sqlToPolicy, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
+export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_FIND_ALL_MAX_ROWS, DEFAULT_MAX_PAGES, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, DEFAULT_PAGE_SIZE, DEFAULT_STRING_COLUMN_LENGTH, JUNCTION_TABLES_SQL, MAX_LOGICAL_NESTING_DEPTH, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, RebasePaginationError, and, buildCollectionFromTableMetadata, buildCompositeId, buildConditionContext, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, collectAllPages, cond, createDataSourceRegistry, createPaginationHelpers, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getChildViewDeclaringProperties, getChildViewRelationPropertyKeys, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEntityChildViews, getEnumVarName, getGeneratedPolicyNames, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getRelationTargetPath, getSubcollections, getTableName, getTableVarName, isAddressableId, isJunctionBackedRelation, isPropertyBuilder, isRebaseInternalTable, isRelationalCollection, normalizeEmail, normalizeToEntityRelation, or, paginateFind, parseIdValues, policyToPostgres, registerConditionOperations, relationalCollections, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveFindWindow, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolveRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, resolveStringColumnLength, sanitizeData, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, sqlToPolicy, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
 
 //# sourceMappingURL=index.es.js.map