@rebasepro/common 0.8.0 → 0.9.0

package/src/util/collections.ts

@@ -1,7 +1,7 @@
 import {
     DefaultSelectedViewBuilder,
     DefaultSelectedViewParams,
-    EntityCollection,
+    CollectionConfig,
     Properties,
     Property
 } from "@rebasepro/types";
@@ -99,7 +99,7 @@ export function resolveDefaultSelectedView(
 }
 
 
-export function getLocalChangesBackup(collection: EntityCollection) {
+export function getLocalChangesBackup(collection: CollectionConfig) {
     if (!collection.localChangesBackup) {
         return "manual_apply";
     }
@@ -108,12 +108,12 @@ export function getLocalChangesBackup(collection: EntityCollection) {
 }
 
 /**
- * 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
  */
-export function getPrimaryKeys<M extends Record<string, unknown>>(collection: EntityCollection<M>): Extract<keyof M, string>[] {
+export function getPrimaryKeys<M extends Record<string, unknown>>(collection: CollectionConfig<M>): Extract<keyof M, string>[] {
     const properties = collection.properties;
     if (!properties) {
         return ["id"] as Extract<keyof M, string>[];

package/src/util/entities.ts

@@ -81,7 +81,7 @@ export function getDefaultValueFortype(type: DataType): unknown {
 }
 
 /**
- * Update the automatic values in an entity before save
+ * Update the automatic values in a entity before save
  * @group Driver
  */
 export function updateDateAutoValues<M extends Record<string, unknown>>({
@@ -117,7 +117,7 @@ export function updateDateAutoValues<M extends Record<string, unknown>>({
 }
 
 /**
- * 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
@@ -148,7 +148,7 @@ export function getReferenceFrom<M extends Record<string, unknown>>(entity: Enti
 }
 
 export function getRelationFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityRelation {
-    return new EntityRelation(entity.id, entity.path, entity);
+    return new EntityRelation(entity.id, entity.path, entity as unknown as Record<string, unknown>);
 }
 
 /**
@@ -179,7 +179,7 @@ export function normalizeToEntityRelation(value: unknown, propertyType?: string)
     return new EntityRelation(
         obj.id as string | number,
         obj.path as string,
-        obj.data as Entity | undefined
+        obj.data as Record<string, unknown> | undefined
     );
 }
 

package/src/util/filter-operator-resolution.ts

@@ -0,0 +1,81 @@
+import {
+    ALL_WHERE_FILTER_OPS,
+    DataType,
+    getDataSourceCapabilities,
+    Property,
+    WhereFilterOp
+} from "@rebasepro/types";
+
+/**
+ * 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.
+ */
+const COMPARISON_OPS: readonly WhereFilterOp[] = ["==", "!=", ">", ">=", "<", "<="];
+const NULL_CHECK_OPS: readonly WhereFilterOp[] = ["is-null", "is-not-null"];
+const MEMBERSHIP_OPS: readonly WhereFilterOp[] = ["in", "not-in"];
+const PATTERN_OPS: readonly WhereFilterOp[] = ["like", "ilike", "not-like", "not-ilike"];
+
+const DEFAULT_OPS_BY_TYPE: Partial<Record<DataType, readonly WhereFilterOp[]>> = {
+    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]
+    // geopoint, map, vector, binary, array (as a container): not filterable
+    // through the generic filter UI.
+};
+
+/** Operators offered when the property is an *array of* a filterable type. */
+const ARRAY_OPS: readonly WhereFilterOp[] = ["array-contains", "array-contains-any"];
+
+export interface ResolveFilterOperatorsParams {
+    /**
+     * The property to filter on. For array properties, pass the **item**
+     * property (`property.of`) together with `isArray: true` — the same
+     * convention the filter field dispatchers use.
+     */
+    property: Property;
+    /** True when filtering an array of `property`. */
+    isArray?: boolean;
+    /**
+     * The engine backing the collection (`collection.engine`, e.g.
+     * `"postgres"`, `"firestore"`). Falls back to the default engine's
+     * capabilities when omitted.
+     */
+    engine?: string;
+}
+
+/**
+ * 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
+ */
+export function resolveFilterOperators({
+    property,
+    isArray,
+    engine
+}: ResolveFilterOperatorsParams): WhereFilterOp[] {
+    const typeDefaults: readonly WhereFilterOp[] = 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 !== undefined ? new Set(narrowing) : undefined;
+
+    return typeDefaults.filter(op =>
+        engineOps.has(op) && (narrowingSet === undefined || narrowingSet.has(op)));
+}

package/src/util/index.ts

@@ -15,3 +15,4 @@ export * from "./callbacks";
 export * from "./relations";
 export * from "./conditions";
 export * from "./navigation_utils";
+export * from "./filter-operator-resolution";

package/src/util/navigation_from_path.ts

@@ -1,4 +1,4 @@
-import { EntityCollection } from "@rebasepro/types";
+import { CollectionConfig } from "@rebasepro/types";
 type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = { key: string; [key: string]: unknown };
 import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
 import { getSubcollections } from "./resolutions";
@@ -13,7 +13,7 @@ export interface NavigationViewEntityInternal<M extends Record<string, unknown>>
     entityId: string | number;
     slug: string;
     path: string;
-    parentCollection: EntityCollection<M>;
+    parentCollection: CollectionConfig<M>;
 }
 
 export interface NavigationViewCollectionInternal<M extends Record<string, unknown>> {
@@ -21,7 +21,7 @@ export interface NavigationViewCollectionInternal<M extends Record<string, unkno
     id: string;
     slug: string;
     path: string;
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
 }
 
 export interface NavigationViewEntityCustomInternal<M extends Record<string, unknown>> {
@@ -34,7 +34,7 @@ export interface NavigationViewEntityCustomInternal<M extends Record<string, unk
 
 export function getNavigationEntriesFromPath(props: {
     path: string,
-    collections: EntityCollection[] | undefined,
+    collections: CollectionConfig[] | undefined,
     currentFullPath?: string,
     contextEntityViews?: EntityCustomView[]
 }): NavigationViewInternal[] {

package/src/util/navigation_utils.ts

@@ -1,4 +1,4 @@
-import { EntityCollection } from "@rebasepro/types";
+import { CollectionConfig } from "@rebasepro/types";
 
 import { getSubcollections } from "./resolutions";
 
@@ -33,13 +33,13 @@ export function getLastSegment(path: string) {
     return cleanPath;
 }
 
-export function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string {
+export function resolveCollectionPathIds(path: string, allCollections: CollectionConfig[]): string {
     let remainingPath = removeInitialAndTrailingSlashes(path);
     if (!remainingPath) {
         return "";
     }
 
-    let currentCollections: EntityCollection[] | undefined = allCollections;
+    let currentCollections: CollectionConfig[] | undefined = allCollections;
     const resolvedPathParts: string[] = [];
 
     while (remainingPath.length > 0) {
@@ -53,7 +53,7 @@ export function resolveCollectionPathIds(path: string, allCollections: EntityCol
 
         let foundMatch = false;
         // Sort potential matches by length descending to prioritize longer matches (e.g., "a/b" over "a")
-        const potentialMatches: { col: EntityCollection; match: string; }[] = currentCollections
+        const potentialMatches: { col: CollectionConfig; match: string; }[] = currentCollections
             .flatMap(col => [{
                 col,
                 match: col.slug
@@ -76,7 +76,7 @@ export function resolveCollectionPathIds(path: string, allCollections: EntityCol
                 break; // Path ends with a collection segment
             }
 
-            // The next segment must be an entity ID
+            // The next segment must be a entity ID
             const idSeparatorIndex = remainingPath.indexOf("/");
             let entityId: string | number;
             if (idSeparatorIndex > -1) {
@@ -87,7 +87,7 @@ export function resolveCollectionPathIds(path: string, allCollections: EntityCol
                 // but handle it defensively: assume the rest is the ID
                 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.`);
                 // Even if it ends here, we still need to push the ID
             }
 
@@ -123,7 +123,7 @@ export function resolveCollectionPathIds(path: string, allCollections: EntityCol
  * @param slugOrPath
  * @param collections
  */
-export function getCollectionBySlugWithin(slugOrPath: string, collections: EntityCollection[]): EntityCollection | undefined {
+export function getCollectionBySlugWithin(slugOrPath: string, collections: CollectionConfig[]): CollectionConfig | undefined {
 
     const subpaths = removeInitialAndTrailingSlashes(slugOrPath).split("/");
     if (subpaths.length % 2 === 0) {
@@ -131,7 +131,7 @@ export function getCollectionBySlugWithin(slugOrPath: string, collections: Entit
     }
 
     const subpathCombinations = getCollectionPathsCombinations(subpaths);
-    let result: EntityCollection | undefined;
+    let result: CollectionConfig | undefined;
     for (let i = 0; i < subpathCombinations.length; i++) {
         const subpathCombination = subpathCombinations[i];
         const navigationEntry = collections && collections

package/src/util/parent_references_from_path.ts

@@ -1,10 +1,10 @@
-import { EntityCollection, EntityReference } from "@rebasepro/types";
+import { CollectionConfig, EntityReference } from "@rebasepro/types";
 import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
 import { getSubcollections } from "./resolutions";
 
 export function getParentReferencesFromPath(props: {
     path: string,
-    collections: EntityCollection[] | undefined,
+    collections: CollectionConfig[] | undefined,
     currentFullPath?: string,
 }): EntityReference[] {
 
@@ -21,7 +21,7 @@ export function getParentReferencesFromPath(props: {
     for (let i = 0; i < subpathCombinations.length; i++) {
         const subpathCombination = subpathCombinations[i];
 
-        const collection: EntityCollection | undefined = collections && collections.find((entry) => entry.slug === subpathCombination);
+        const collection: CollectionConfig | undefined = collections && collections.find((entry) => entry.slug === subpathCombination);
 
         // If we find a collection, we add the reference and continue
         if (collection) {

package/src/util/permissions.test.ts

@@ -1,5 +1,5 @@
 import { canCreateEntity, canEditEntity, canDeleteEntity, canReadCollection } from "./permissions";
-import { EntityCollection, AuthController, Entity, User, SecurityRule } from "@rebasepro/types";
+import { CollectionConfig, AuthController, Entity, User, SecurityRule } from "@rebasepro/types";
 
 describe("Permissions Evaluator", () => {
 
@@ -46,7 +46,7 @@ describe("Permissions Evaluator", () => {
         user: null
     };
 
-    const createMockCollection = (rules?: SecurityRule[]): EntityCollection => ({
+    const createMockCollection = (rules?: SecurityRule[]): CollectionConfig => ({
         slug: "test",
         name: "Test",
         table: "test",

package/src/util/permissions.ts

@@ -1,4 +1,4 @@
-import { Entity, EntityCollection, getDataSourceCapabilities, SecurityOperation, SecurityRule, User } from "@rebasepro/types";
+import { Entity, CollectionConfig, getDataSourceCapabilities, SecurityOperation, SecurityRule, User } from "@rebasepro/types";
 import { securityRuleToConditions } from "./policy/securityRuleToConditions";
 import { evaluatePolicy, PolicyEvalContext, TriState } from "./policy/evaluatePolicy";
 
@@ -35,7 +35,7 @@ function kleeneAnd(values: TriState[]): TriState {
 }
 
 /** The operations a rule covers, mirroring the Postgres generator's resolution. */
-function ruleOperations(rule: SecurityRule): SecurityOperation[] {
+function ruleOperations(rule: SecurityRule): readonly SecurityOperation[] {
     return rule.operations && rule.operations.length > 0
         ? rule.operations
         : [rule.operation ?? "all"];
@@ -83,7 +83,7 @@ function resolveTriState(value: TriState, onUnknown: UnknownResolution): boolean
  *   for optimistic UI gating; enforcement callers should pass `"deny"`.
  */
 export function checkOperation<M extends Record<string, unknown>, USER extends User>(
-    collection: EntityCollection<M>,
+    collection: CollectionConfig<M>,
     authContext: AuthContext<USER>,
     entity: Entity<M> | null,
     targetOperation: SecurityOperation,
@@ -129,7 +129,7 @@ export function checkOperation<M extends Record<string, unknown>, USER extends U
 
 export function canReadCollection<M extends Record<string, unknown>, USER extends User>
     (
-        collection: EntityCollection<M>,
+        collection: CollectionConfig<M>,
         authContext: AuthContext<USER>
     ): boolean {
     return checkOperation(collection, authContext, null, "select");
@@ -137,7 +137,7 @@ export function canReadCollection<M extends Record<string, unknown>, USER extend
 
 export function canEditEntity<M extends Record<string, unknown>, USER extends User>
     (
-        collection: EntityCollection<M>,
+        collection: CollectionConfig<M>,
         authContext: AuthContext<USER>,
         path: string,
         entity: Entity<M> | null
@@ -147,7 +147,7 @@ export function canEditEntity<M extends Record<string, unknown>, USER extends Us
 
 export function canCreateEntity<M extends Record<string, unknown>, USER extends User>
     (
-        collection: EntityCollection<M>,
+        collection: CollectionConfig<M>,
         authContext: AuthContext<USER>,
         path: string,
         entity: Entity<M> | null
@@ -157,7 +157,7 @@ export function canCreateEntity<M extends Record<string, unknown>, USER extends
 
 export function canDeleteEntity<M extends Record<string, unknown>, USER extends User>
     (
-        collection: EntityCollection<M>,
+        collection: CollectionConfig<M>,
         authContext: AuthContext<USER>,
         path: string,
         entity: Entity<M> | null

package/src/util/policy/evaluatePolicy.ts

@@ -55,6 +55,9 @@ export function evaluatePolicy(expr: PolicyExpression, ctx: PolicyEvalContext):
         }
         case "authenticated":
             return ctx.uid != null;
+        case "existsIn":
+            // A membership subquery cannot be run client-side — server-authoritative.
+            return "unknown";
         case "raw":
             // Arbitrary SQL cannot be evaluated client-side — never guess.
             return "unknown";
@@ -96,6 +99,9 @@ function resolveOperand(operand: PolicyOperand, ctx: PolicyEvalContext): Resolve
             // Can't resolve a row column without the row.
             if (!ctx.entity) return { known: false };
             return { known: true, value: ctx.entity.values[operand.name] };
+        case "outerField":
+            // Only meaningful inside an `existsIn` subquery (server-authoritative).
+            return { known: false };
     }
 }
 

package/src/util/policy/policyToPostgres.ts

@@ -1,5 +1,38 @@
-import { EntityCollection, PolicyExpression, PolicyOperand, PolicyCompareOperator, Property } from "@rebasepro/types";
+import { CollectionConfig, PolicyExpression, PolicyOperand, PolicyCompareOperator, Property, ExistsInPolicyExpression } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
+import { getTableName } from "../relations";
+
+/**
+ * Options for {@link policyToPostgres}.
+ */
+export interface PolicyCompileOptions {
+    /**
+     * Resolve a collection by slug. Required to compile
+     * {@link ExistsInPolicyExpression} (`policy.existsIn`) — the compiler needs
+     * the joined collection to derive its table name / schema. When omitted, the
+     * join table falls back to a snake_cased slug.
+     */
+    resolveCollection?: (slug: string) => CollectionConfig | undefined;
+}
+
+/**
+ * The lexical scope threaded through compilation. It changes when we descend
+ * into an `existsIn` subquery: inside it, `field` refers to the joined table
+ * (aliased) while `outerField` refers to the outer RLS row (table-qualified).
+ */
+interface CompileScope {
+    /** Collection whose columns a bare `field` operand resolves against. */
+    fieldCollection?: CollectionConfig;
+    /** SQL prefix for `field` operands (`""` at top level, `"alias".` in a subquery). */
+    fieldPrefix: string;
+    /** The outer RLS collection, for `outerField` operands. */
+    outerCollection?: CollectionConfig;
+    /** SQL prefix for `outerField` operands (`""` at top level, `"schema"."table".` in a subquery). */
+    outerPrefix: string;
+    resolveCollection?: (slug: string) => CollectionConfig | undefined;
+    /** Monotonic counter for generating unique subquery aliases. */
+    alias: { n: number };
+}
 
 /**
  * Compiles a {@link PolicyExpression} to a PostgreSQL boolean SQL string,
@@ -9,7 +42,18 @@ import { toSnakeCase } from "@rebasepro/utils";
  * {@link evaluatePolicy}); the Postgres schema generators call it so that DDL
  * and the admin UI derive from the exact same expression.
  */
-export function policyToPostgres(expr: PolicyExpression, collection?: EntityCollection): string {
+export function policyToPostgres(expr: PolicyExpression, collection?: CollectionConfig, options?: PolicyCompileOptions): string {
+    return compile(expr, {
+        fieldCollection: collection,
+        fieldPrefix: "",
+        outerCollection: collection,
+        outerPrefix: "",
+        resolveCollection: options?.resolveCollection,
+        alias: { n: 0 }
+    });
+}
+
+function compile(expr: PolicyExpression, scope: CompileScope): string {
     switch (expr.kind) {
         case "true":
             return "true";
@@ -18,23 +62,25 @@ export function policyToPostgres(expr: PolicyExpression, collection?: EntityColl
         case "and":
             return expr.operands.length === 0
                 ? "true"
-                : expr.operands.map(o => `(${policyToPostgres(o, collection)})`).join(" AND ");
+                : expr.operands.map(o => `(${compile(o, scope)})`).join(" AND ");
         case "or":
             return expr.operands.length === 0
                 ? "false"
-                : expr.operands.map(o => `(${policyToPostgres(o, collection)})`).join(" OR ");
+                : expr.operands.map(o => `(${compile(o, scope)})`).join(" OR ");
         case "not":
             // Render the common `auth.uid() IS NULL` (unauthenticated) form directly.
             if (expr.operand.kind === "authenticated") return "auth.uid() IS NULL";
-            return `NOT (${policyToPostgres(expr.operand, collection)})`;
+            return `NOT (${compile(expr.operand, scope)})`;
         case "compare":
-            return `${operandToSql(expr.left, collection)} ${COMPARE_SQL[expr.op]} ${operandToSql(expr.right, collection)}`;
+            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":
             // Full-power escape hatch: `{column}` references resolve to the bare
             // column name (matching the previous raw-SQL behavior).
@@ -42,6 +88,34 @@ export function policyToPostgres(expr: PolicyExpression, collection?: EntityColl
     }
 }
 
+/**
+ * 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: ExistsInPolicyExpression, scope: CompileScope): string {
+    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++}`;
+
+    // `outerField` inside the subquery must be qualified with the outer table,
+    // otherwise a bare column name would bind to the joined table instead.
+    const outerTable = scope.outerCollection ? getTableName(scope.outerCollection) : undefined;
+    const outerSchema = schemaOf(scope.outerCollection) ?? "public";
+    const outerPrefix = outerTable ? `"${outerSchema}"."${outerTable}".` : "";
+
+    const innerScope: CompileScope = {
+        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)})`;
+}
+
 const COMPARE_SQL: Record<PolicyCompareOperator, string> = {
     eq: "=",
     neq: "!=",
@@ -51,10 +125,12 @@ const COMPARE_SQL: Record<PolicyCompareOperator, string> = {
     gte: ">="
 };
 
-function operandToSql(operand: PolicyOperand, collection?: EntityCollection): string {
+function operandToSql(operand: PolicyOperand, scope: CompileScope): string {
     switch (operand.kind) {
         case "field":
-            return resolveColumnName(operand.name, collection);
+            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":
@@ -64,7 +140,11 @@ function operandToSql(operand: PolicyOperand, collection?: EntityCollection): st
     }
 }
 
-function resolveColumnName(propName: string, collection?: EntityCollection): string {
+function schemaOf(collection?: CollectionConfig): string | undefined {
+    return (collection as { schema?: string } | undefined)?.schema || undefined;
+}
+
+function resolveColumnName(propName: string, collection?: CollectionConfig): string {
     const prop = collection?.properties?.[propName] as Property | undefined;
     if (prop && "columnName" in prop && typeof (prop as { columnName?: unknown }).columnName === "string") {
         return (prop as { columnName: string }).columnName;
@@ -80,6 +160,6 @@ function quoteLiteral(value: string | number | boolean | null): string {
 }
 
 /** Sorted, single-quoted `ARRAY['a','b']` — matches the generators' output. */
-function rolesArraySql(roles: string[]): string {
+function rolesArraySql(roles: readonly string[]): string {
     return `ARRAY[${[...roles].sort().map(r => `'${r}'`).join(",")}]`;
 }

package/src/util/references.ts

@@ -1,6 +1,6 @@
-import { EntityCollection } from "@rebasepro/types";
+import { CollectionConfig } from "@rebasepro/types";
 
-export function getEntityImagePreviewPropertyKey<M extends Record<string, unknown>>(collection: EntityCollection<M>): string | undefined {
+export function getEntityImagePreviewPropertyKey<M extends Record<string, unknown>>(collection: CollectionConfig<M>): string | undefined {
 
     // find first storage property of type image
     for (const key in collection.properties) {

package/src/util/relations.ts

@@ -1,18 +1,18 @@
-import { EntityCollection, getDataSourceCapabilities, Property, Relation, RelationProperty } from "@rebasepro/types";
+import { CollectionConfig, getDataSourceCapabilities, Property, Relation, RelationProperty } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 import { generateForeignKeyName } from "@rebasepro/utils";
 
 export function sanitizeRelation(
     relation: Partial<Relation>,
-    sourceCollection: EntityCollection,
-    resolveCollection?: (slugOrTable: string) => EntityCollection | undefined
+    sourceCollection: CollectionConfig,
+    resolveCollection?: (slugOrTable: string) => CollectionConfig | undefined
 ): Relation {
     if (!relation.target) {
         throw new Error("Relation is missing a `target` collection.");
     }
 
     const rawTarget = relation.target;
-    let targetCollection: EntityCollection | undefined;
+    let targetCollection: CollectionConfig | undefined;
 
     if (typeof rawTarget === "string") {
         if (resolveCollection) {
@@ -20,7 +20,7 @@ export function sanitizeRelation(
         }
         if (!targetCollection) {
             targetCollection = { slug: rawTarget,
-name: rawTarget } as EntityCollection;
+name: rawTarget } as CollectionConfig;
         }
     } else if (typeof rawTarget === "function") {
         const evaluated = rawTarget();
@@ -30,13 +30,13 @@ name: rawTarget } as EntityCollection;
             }
             if (!targetCollection) {
                 targetCollection = { slug: evaluated,
-name: evaluated } as EntityCollection;
+name: evaluated } as CollectionConfig;
             }
         } else {
             targetCollection = evaluated;
         }
     } else if (rawTarget && typeof rawTarget === "object") {
-        targetCollection = rawTarget as EntityCollection;
+        targetCollection = rawTarget as CollectionConfig;
     }
 
     if (!targetCollection) {
@@ -198,10 +198,10 @@ name: evaluated } as EntityCollection;
 }
 
 /** WeakMap cache — same collection instance always yields the same relation map. */
-const _resolvedRelationsCache = new WeakMap<EntityCollection, Record<string, Relation>>();
+const _resolvedRelationsCache = new WeakMap<CollectionConfig, Record<string, Relation>>();
 
 export function resolveCollectionRelations(
-    collection: EntityCollection
+    collection: CollectionConfig
 ): Record<string, Relation> {
     const cached = _resolvedRelationsCache.get(collection);
     if (cached) return cached;
@@ -251,7 +251,7 @@ export function resolveCollectionRelations(
 
                 // We previously skipped if the underlying relation was already registered under
                 // its canonical relationName in section 1. But we need to keep the property mapping
-                // for EntityFetchService to hydrate the relation back to the correct property key.
+                // for FetchService to hydrate the relation back to the correct property key.
                 // Deduplication for Drizzle schema generation is handled in generate-drizzle-schema-logic.ts.
 
                 if (!relation.relationName) {
@@ -275,7 +275,7 @@ export function resolvePropertyRelation({
 }: {
     propertyKey: string;
     property: Property;
-    sourceCollection: EntityCollection;
+    sourceCollection: CollectionConfig;
 }): Relation | undefined {
     if (property.type !== "relation") return undefined;
 
@@ -304,7 +304,7 @@ export function resolvePropertyRelation({
     return undefined;
 }
 
-export function getTableName(collection: EntityCollection): string {
+export function getTableName(collection: CollectionConfig): string {
     if (getDataSourceCapabilities(collection.engine).supportsRelations) {
         return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
     }