@rebasepro/common 0.11.1-canary.gfd39654 → 0.12.0

package/dist/util/entities.d.ts

@@ -49,7 +49,7 @@ export interface RelationRefWithData extends RelationRef {
     readonly data: Entity;
 }
 /**
- * Create a lightweight relation stub for CMS views.
+ * Create a lightweight relation stub for admin views.
  * Replaces inline `{ id, path, __type: "relation" }` object literals.
  */
 export declare function createRelationRef(id: string | number, path: string): RelationRef;

package/dist/util/index.d.ts

@@ -15,3 +15,4 @@ export * from "./resolve-relation";
 export * from "./auth-default-policies";
 export * from "./junction-policies";
 export * from "./conditions";
+export * from "./pg-column-to-property";

package/dist/util/pg-column-to-property.d.ts

@@ -0,0 +1,25 @@
+import type { PostgresProperties, Relation, SecurityRule, TableMetadata } from "@rebasepro/types";
+/**
+ * A collection as introspection can describe it: the table, its columns, the
+ * relations its foreign keys imply, and the RLS policies already on it.
+ *
+ * Deliberately not `Partial<AdminCollection>`, which is what this returned
+ * while it lived in `@rebasepro/studio`. `propertiesOrder` is the only admin
+ * key it produces, and naming the admin view model for one field would put
+ * `@rebasepro/admin-types` on the dependency path of a package the backend
+ * loads.
+ */
+export interface IntrospectedCollection {
+    name: string;
+    slug: string;
+    table: string;
+    properties: PostgresProperties;
+    propertiesOrder: string[];
+    relations?: Relation[];
+    securityRules?: SecurityRule[];
+}
+/**
+ * Builds a collection description from PostgreSQL table metadata.
+ * This is used when creating a new collection from an existing database table.
+ */
+export declare function buildCollectionFromTableMetadata(tableName: string, metadata: TableMetadata): IntrospectedCollection;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/common",
   "type": "module",
-  "version": "0.11.1-canary.gfd39654",
+  "version": "0.12.0",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -40,8 +40,8 @@
   "dependencies": {
     "fast-equals": "6.0.0",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/types": "0.11.1-canary.gfd39654",
-    "@rebasepro/utils": "0.11.1-canary.gfd39654"
+    "@rebasepro/types": "0.12.0",
+    "@rebasepro/utils": "0.12.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",

package/src/data/buildRebaseData.ts

@@ -3,9 +3,11 @@ import {
     DataDriver,
     Entity,
     EntityValues,
+    FindAllParams,
     FindParams,
     FindResponse,
     FindResult,
+    IterateParams,
     LogicalCondition,
     RebaseData,
     RebaseSdkData,
@@ -16,6 +18,7 @@ import {
 } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 import { QueryBuilder } from "./query_builder";
+import { collectAllPages, paginateFind } from "./paginate";
 import { deserializeFilter } from "./filter-dialect";
 import { buildCompositeId, resolvePrimaryKeys, PrimaryKeyInfo } from "../util/identity";
 
@@ -95,6 +98,52 @@ function rowToEntity<M extends Record<string, unknown>>(
     };
 }
 
+/**
+ * The relation envelope `toCmsRow` writes where a relation was:
+ * `{ id, path, __type: "relation", data: { id, path, values } }`. It is the
+ * admin's view-model, and the only pipeline that produces one is postgres'.
+ */
+function isRelationEnvelope(
+    value: unknown
+): value is { __type: "relation"; data?: { values?: Record<string, unknown> } } {
+    return typeof value === "object"
+        && value !== null
+        && !Array.isArray(value)
+        && (value as { __type?: unknown }).__type === "relation";
+}
+
+/** The target's own columns, as `toRestRow` would have inlined them. */
+function inlineEnvelope(envelope: { data?: { values?: Record<string, unknown> } }): Record<string, unknown> {
+    return envelope.data?.values ?? {};
+}
+
+/**
+ * Replace every relation envelope on a row with the target's flat columns.
+ *
+ * The SDK serves one relation shape — the inlined one (see
+ * {@link RestFetchService}) — and reads that come back through a *driver*
+ * method rather than the REST pipeline still carry envelopes. Realtime is the
+ * one such read left: there is no `listenForRest`, so the rows arrive shaped
+ * for the admin and are flattened here instead.
+ *
+ * Only applied where the REST pipeline is the contract (see `find`); a driver
+ * without a `restFetchService` keeps whatever it returns, so the admin's own
+ * path through {@link buildRebaseData} is untouched.
+ */
+function inlineRelationRefs(row: Record<string, unknown>): Record<string, unknown> {
+    let out: Record<string, unknown> | undefined;
+    for (const [key, value] of Object.entries(row)) {
+        if (isRelationEnvelope(value)) {
+            out = out ?? { ...row };
+            out[key] = inlineEnvelope(value);
+        } else if (Array.isArray(value) && value.some(isRelationEnvelope)) {
+            out = out ?? { ...row };
+            out[key] = value.map((item) => isRelationEnvelope(item) ? inlineEnvelope(item) : item);
+        }
+    }
+    return out ?? row;
+}
+
 function createDriverAccessor<M extends Record<string, unknown> = Record<string, unknown>>(
     driver: DataDriver,
     slug: string,
@@ -107,9 +156,23 @@ function createDriverAccessor<M extends Record<string, unknown> = Record<string,
             const limit = params?.limit ?? 20;
             const offset = params?.offset ?? 0;
 
-            // Use the RestFetchService for include-aware queries when available
+            // One relation shape, whatever the call looks like.
+            //
+            // This used to fork on `include`: asking for one ran the REST
+            // pipeline, which inlines a relation as the target's own columns;
+            // not asking ran the driver's own fetch, which eagerly loaded
+            // *every* relation and put a `{ __type: "relation" }` envelope
+            // where the foreign key was. The same method answered in two
+            // shapes, the generated types described only one, and a column
+            // typed `string` arrived as an object.
+            //
+            // The REST pipeline is the published contract — the shape the HTTP
+            // API serves for this same query, and what `RestFetchService`
+            // documents — so every read goes through it when the driver has
+            // one. Drivers without one (every browser driver, and so the
+            // admin's own path through `buildRebaseData`) are untouched.
             const fetchService = driver.restFetchService;
-            const rows = (fetchService && params?.include && params.include.length > 0)
+            const rows = fetchService
                 ? await fetchService.fetchCollectionForRest(
                     slug,
                     {
@@ -120,7 +183,7 @@ function createDriverAccessor<M extends Record<string, unknown> = Record<string,
                         order: params?.orderBy?.[1],
                         searchString: params?.searchString
                     },
-                    params.include
+                    params?.include
                 )
                 : await driver.fetchCollection<M>({
                     path: slug,
@@ -147,7 +210,12 @@ function createDriverAccessor<M extends Record<string, unknown> = Record<string,
         },
 
         async findById(id: string | number): Promise<Entity<M> | undefined> {
-            const row = await driver.fetchOne<M>({ path: slug, id: id });
+            // Same contract as `find` above: one row read the same way the
+            // collection read is, so `find()[0]` and `findById()` agree.
+            const fetchService = driver.restFetchService;
+            const row = fetchService
+                ? await fetchService.fetchOneForRest(slug, id)
+                : await driver.fetchOne<M>({ path: slug, id: id });
             return row ? rowToEntity<M>(row, slug, getPks()) : undefined;
         },
 
@@ -204,6 +272,10 @@ values: {} as Record<string, unknown> }
             ? (params: FindParams<M> | undefined, onUpdate: (response: FindResponse<M>) => void, onError?: (error: Error) => void) => {
                 const limit = params?.limit ?? 20;
                 const offset = params?.offset ?? 0;
+                // Realtime has no REST-pipeline equivalent, so the rows arrive
+                // admin-shaped. Flatten them to the one shape the rest of this
+                // accessor serves.
+                const normalize = driver.restFetchService ? inlineRelationRefs : (row: Record<string, unknown>) => row;
                 return driver.listenCollection!<M>({
                     path: slug,
                     limit: params?.limit,
@@ -214,7 +286,7 @@ values: {} as Record<string, unknown> }
                     searchString: params?.searchString,
                     onUpdate: (entities) => {
                         onUpdate({
-                            data: entities.map((row: Record<string, unknown>) => rowToEntity<M>(row, slug, getPks())),
+                            data: entities.map((row: Record<string, unknown>) => rowToEntity<M>(normalize(row), slug, getPks())),
                             meta: {
                                 total: entities.length,
                                 limit,
@@ -229,10 +301,11 @@ values: {} as Record<string, unknown> }
 
         listenById: driver.listenOne
             ? (id: string | number, onUpdate: (entity: Entity<M> | undefined) => void, onError?: (error: Error) => void) => {
+                const normalize = driver.restFetchService ? inlineRelationRefs : (row: Record<string, unknown>) => row;
                 return driver.listenOne!<M>({
                     path: slug,
                     id: id,
-                    onUpdate: (entity) => onUpdate(entity ? rowToEntity<M>(entity, slug, getPks()) : undefined),
+                    onUpdate: (entity) => onUpdate(entity ? rowToEntity<M>(normalize(entity), slug, getPks()) : undefined),
                     onError
                 });
             } : undefined,
@@ -391,13 +464,24 @@ class SdkQueryBuilder<M extends Record<string, unknown> = Record<string, unknown
  * so the backend SDK is byte-for-byte the same shape as the frontend client.
  */
 function toSdkCollectionClient<M extends Record<string, unknown>>(
-    snap: CollectionAccessor<M>
+    snap: CollectionAccessor<M>,
+    slug = "collection"
 ): SDKCollectionClient<M> {
     const client: SDKCollectionClient<M> = {
         async find(params?: FindParams<M>): Promise<FindResult<M>> {
             const res = await snap.find(params);
             return { data: res.data.map(entityToRow), meta: res.meta };
         },
+        // Pagination is shared with the HTTP client rather than reimplemented:
+        // both transports satisfy the same `SDKCollectionClient`, so a walk that
+        // behaved differently in-process than over the wire would be a bug the
+        // type system could not see.
+        iterate(params?: IterateParams<M>) {
+            return paginateFind<M>((p) => client.find(p), params, slug);
+        },
+        findAll(params?: FindAllParams<M>) {
+            return collectAllPages<M>((p) => client.find(p), params, slug);
+        },
         async findById(id: string | number): Promise<M | undefined> {
             const s = await snap.findById(id);
             return s ? entityToRow(s) : undefined;
@@ -453,7 +537,7 @@ function toSdkCollectionClient<M extends Record<string, unknown>>(
 /**
  * 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.
+ * `{ id, path, values }` view-model the admin admin renders.
  */
 function toEntityAccessor<M extends Record<string, unknown>>(
     sdk: SDKCollectionClient<M>,
@@ -508,10 +592,10 @@ function toEntityAccessor<M extends Record<string, unknown>>(
 /**
  * Wrap a flat {@link RebaseSdkData} into a Entity-shaped {@link RebaseData}.
  *
- * This is the **CMS boundary**: the SDK client (`client.data`) returns flat
+ * This is the **admin boundary**: the SDK client (`client.data`) returns flat
  * rows, but the admin renders the `Entity` view-model (`entity.values.*`).
  * `core/Rebase.tsx` wraps `client.data` through this before handing it to the
- * CMS `RebaseDataContext` — without it the admin renders rows with only their
+ * admin `RebaseDataContext` — without it the admin renders rows with only their
  * `id`.
  */
 export function wrapAsEntityData(sdkData: RebaseSdkData, options?: EntityDataOptions): RebaseData {
@@ -553,7 +637,7 @@ export function wrapAsSdkData(entityData: RebaseData): RebaseSdkData {
     function getAccessor(slug: string): SDKCollectionClient {
         let accessor = cache.get(slug);
         if (!accessor) {
-            accessor = toSdkCollectionClient(entityData.collection(slug));
+            accessor = toSdkCollectionClient(entityData.collection(slug), slug);
             cache.set(slug, accessor);
         }
         return accessor;
@@ -576,8 +660,12 @@ export function wrapAsSdkData(entityData: RebaseData): RebaseSdkData {
  *
  * 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).
+ * identical in shape to the frontend SDK client, down to how a relation is
+ * served: a foreign key stays a foreign key, and a relation named in `include`
+ * arrives as the target's own columns. The `{ __type: "relation" }` envelope is
+ * the admin's view-model and never reaches here.
+ *
+ * The admin uses {@link buildRebaseData} (Entity) over its own driver.
  */
 export function buildSdkData(driver: DataDriver): RebaseSdkData {
     return wrapAsSdkData(buildRebaseData(driver));

package/src/data/paginate.ts

@@ -0,0 +1,290 @@
+import {
+    FilterValues,
+    FieldPath,
+    FindAllParams,
+    FindParams,
+    FindResult,
+    IterateParams,
+    WhereFilterOp
+} from "@rebasepro/types";
+
+/**
+ * The pagination engine behind `iterate()` / `findAll()`.
+ *
+ * It lives here, above both transports, on purpose: the HTTP client and the
+ * in-process accessor implement the same `SDKCollectionClient` contract, and a
+ * helper written twice is a helper that drifts. Both call into this file, so
+ * "the SDK paginates like *this*" has exactly one definition.
+ *
+ * Everything below is expressed in terms of a single `find(params)` function,
+ * which is all either transport has to supply.
+ */
+
+/** Rows requested per page when the caller does not say. */
+export const DEFAULT_PAGE_SIZE = 200;
+
+/** Rows `findAll()` will materialise before it refuses to continue. */
+export const DEFAULT_FIND_ALL_MAX_ROWS = 10_000;
+
+/**
+ * Requests one walk may make before it gives up on the server ever saying
+ * `hasMore: false`. At the default page size that is two million rows — far
+ * past any legitimate walk, and short of running forever.
+ */
+export const DEFAULT_MAX_PAGES = 10_000;
+
+/** Why a pagination walk refused to continue. */
+export type PaginationErrorCode =
+    /** `findAll()` matched more rows than its ceiling allows. */
+    | "max-rows"
+    /** The walk made its maximum number of requests without the server finishing. */
+    | "max-pages"
+    /** A cursor row carried no value for the cursor column. */
+    | "cursor-missing"
+    /** Two consecutive pages ended on the same cursor value, so the walk cannot advance. */
+    | "cursor-stalled"
+    /** A `cursor` was asked for on one column while `orderBy` sorted by another. */
+    | "cursor-order-mismatch";
+
+/**
+ * Thrown when a walk stops for a reason the caller needs to know about.
+ *
+ * Every one of these is a case where the alternative would be silent: a
+ * truncated array that looks complete, or a loop that never returns. Check
+ * {@link code} to tell them apart.
+ */
+export class RebasePaginationError extends Error {
+    readonly code: PaginationErrorCode;
+
+    constructor(code: PaginationErrorCode, message: string) {
+        super(message);
+        this.name = "RebasePaginationError";
+        this.code = code;
+        // Keeps `instanceof` working when this is compiled down for an older
+        // target, where extending a builtin otherwise loses the prototype.
+        Object.setPrototypeOf(this, RebasePaginationError.prototype);
+    }
+}
+
+/** 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>>;
+
+function normalizePageSize(raw: number | undefined): number {
+    if (raw === undefined || !Number.isFinite(raw)) return DEFAULT_PAGE_SIZE;
+    return Math.max(1, Math.floor(raw));
+}
+
+function normalizeMaxPages(raw: number | undefined): number {
+    if (raw === undefined) return DEFAULT_MAX_PAGES;
+    if (raw === Number.POSITIVE_INFINITY) return raw;
+    if (!Number.isFinite(raw)) return DEFAULT_MAX_PAGES;
+    return Math.max(1, Math.floor(raw));
+}
+
+function normalizeMaxRows(raw: number | undefined): number {
+    if (raw === undefined) return DEFAULT_FIND_ALL_MAX_ROWS;
+    if (raw === Number.POSITIVE_INFINITY) return raw;
+    if (!Number.isFinite(raw)) return DEFAULT_FIND_ALL_MAX_ROWS;
+    return Math.max(0, Math.floor(raw));
+}
+
+/**
+ * Add one condition to a `where` map without disturbing what is already there.
+ *
+ * The caller's own filter on the cursor column has to survive — dropping it
+ * would widen the query, which is the silent-filter-loss failure mode — so a
+ * second condition on the same column becomes the array-of-tuples form that
+ * `FindParams.where` already accepts, and both are AND-ed.
+ */
+function appendCondition<M extends Record<string, unknown>>(
+    where: FilterValues<FieldPath<M>> | undefined,
+    column: string,
+    condition: [WhereFilterOp, unknown]
+): FilterValues<FieldPath<M>> {
+    const next = { ...(where ?? {}) } as Record<string, unknown>;
+    const existing = next[column];
+    if (existing === undefined) {
+        next[column] = condition;
+    } else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) {
+        next[column] = [...(existing as [WhereFilterOp, unknown][]), condition];
+    } else {
+        next[column] = [existing, condition];
+    }
+    return next as FilterValues<FieldPath<M>>;
+}
+
+function cursorEquals(a: unknown, b: unknown): boolean {
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    return Object.is(a, b);
+}
+
+/**
+ * Walk every row a query matches, yielding one row at a time and fetching the
+ * next page only when the consumer asks for it.
+ *
+ * See {@link SDKCollectionClient.iterate} for the caller-facing contract,
+ * including the offset-drift caveat and the `cursor` alternative.
+ *
+ * @param find   the transport's single-page read
+ * @param params `find()` parameters minus the window, plus the walk options
+ * @param label  the collection name, so an error says which walk failed
+ */
+export async function* paginateFind<M extends Record<string, unknown> = Record<string, unknown>>(
+    find: PageFinder<M>,
+    params?: IterateParams<M>,
+    label = "collection"
+): AsyncGenerator<M, void, undefined> {
+    const {
+        pageSize,
+        cursor,
+        maxPages,
+        ...rest
+    } = (params ?? {}) as IterateParams<M> & Record<string, unknown>;
+
+    const findParams = { ...rest } as FindParams<M>;
+    const size = normalizePageSize(pageSize as number | undefined);
+    const pageCap = normalizeMaxPages(maxPages as number | undefined);
+
+    // ── Cursor (keyset) setup ────────────────────────────────────────────────
+    const cursorField = typeof cursor === "string" ? cursor : cursor?.field;
+    const requestedDirection = (typeof cursor === "object" && cursor !== null)
+        ? cursor.direction
+        : undefined;
+
+    let direction: "asc" | "desc" = "asc";
+    if (cursorField) {
+        const orderBy = findParams.orderBy;
+        if (orderBy && orderBy[0] !== cursorField) {
+            throw new RebasePaginationError(
+                "cursor-order-mismatch",
+                `Cannot seek on "${cursorField}" while ordering "${label}" by "${orderBy[0]}": ` +
+                `keyset pagination only advances along the column the query is sorted by. ` +
+                `Order by "${cursorField}", or drop the cursor and page by offset.`
+            );
+        }
+        direction = requestedDirection ?? orderBy?.[1] ?? "asc";
+        findParams.orderBy = [cursorField, direction] as FindParams<M>["orderBy"];
+    }
+    const seekOp: WhereFilterOp = direction === "desc" ? "<" : ">";
+    const baseWhere = findParams.where;
+
+    let offset = 0;
+    let pages = 0;
+    let cursorValue: unknown;
+    let seeking = false;
+
+    for (;;) {
+        if (pages >= pageCap) {
+            throw new RebasePaginationError(
+                "max-pages",
+                `Iterating "${label}" made ${pages} requests without the server reporting the end of ` +
+                `the collection. Stopping rather than looping forever — raise \`maxPages\` if the walk ` +
+                `is genuinely this long, or check that the backend sets \`meta.hasMore\`.`
+            );
+        }
+
+        const pageParams: FindParams<M> = { ...findParams, limit: size };
+        if (cursorField) {
+            if (seeking) {
+                pageParams.where = appendCondition<M>(baseWhere, cursorField, [seekOp, cursorValue]);
+            }
+        } else {
+            pageParams.offset = offset;
+        }
+
+        const page = await find(pageParams);
+        pages += 1;
+
+        const rows = page?.data ?? [];
+        // A page with nothing on it always ends the walk, whatever the server
+        // claims about `hasMore` — there is no cursor to advance and no offset
+        // that would ever move past it.
+        if (rows.length === 0) return;
+
+        for (const row of rows) {
+            yield row;
+        }
+
+        // The server is the only authority on whether more rows exist. Never
+        // infer it from `rows.length >= size`: a last page that happens to be
+        // exactly full is indistinguishable from a middle one, and guessing
+        // there drops every row after it.
+        if (page?.meta?.hasMore !== true) return;
+
+        if (cursorField) {
+            const last = rows[rows.length - 1] as Record<string, unknown>;
+            const nextValue = last?.[cursorField];
+            if (nextValue === undefined || nextValue === null) {
+                throw new RebasePaginationError(
+                    "cursor-missing",
+                    `Cannot seek past the last row of "${label}": it has no value for the cursor ` +
+                    `column "${cursorField}". Pick a column that is present and non-null on every row.`
+                );
+            }
+            if (seeking && cursorEquals(nextValue, cursorValue)) {
+                throw new RebasePaginationError(
+                    "cursor-stalled",
+                    `Iterating "${label}" is stuck: two pages in a row ended at ` +
+                    `${cursorField}=${String(nextValue)}. The cursor column has to be unique — a ` +
+                    `repeated value cannot be seeked past, and continuing would either loop forever ` +
+                    `or skip the duplicates. Use the primary key, or page by offset.`
+                );
+            }
+            cursorValue = nextValue;
+            seeking = true;
+        } else {
+            // Advance by what actually arrived, not by the page size: a server
+            // free to return fewer rows than asked for would otherwise leave a
+            // hole in the walk.
+            offset += rows.length;
+        }
+    }
+}
+
+/**
+ * {@link paginateFind}, collected into an array under a ceiling.
+ *
+ * See {@link SDKCollectionClient.findAll}.
+ */
+export async function collectAllPages<M extends Record<string, unknown> = Record<string, unknown>>(
+    find: PageFinder<M>,
+    params?: FindAllParams<M>,
+    label = "collection"
+): Promise<M[]> {
+    const { maxRows, ...rest } = (params ?? {}) as FindAllParams<M> & Record<string, unknown>;
+    const cap = normalizeMaxRows(maxRows as number | undefined);
+
+    const out: M[] = [];
+    for await (const row of paginateFind<M>(find, rest as IterateParams<M>, label)) {
+        out.push(row);
+        if (out.length > cap) {
+            throw new RebasePaginationError(
+                "max-rows",
+                `findAll("${label}") matched more than ${cap} rows. Returning the first ${cap} would ` +
+                `look like the whole answer and quietly not be one, so this throws instead. Raise ` +
+                `\`maxRows\` if you meant to load them all, or stream with \`iterate()\`.`
+            );
+        }
+    }
+    return out;
+}
+
+/**
+ * Build the `iterate` / `findAll` pair for one collection from its `find`.
+ *
+ * Both transports call this, which is what keeps the two implementations from
+ * being two implementations.
+ */
+export function createPaginationHelpers<M extends Record<string, unknown> = Record<string, unknown>>(
+    find: PageFinder<M>,
+    label: string
+): {
+    iterate: (params?: IterateParams<M>) => AsyncIterableIterator<M>;
+    findAll: (params?: FindAllParams<M>) => Promise<M[]>;
+} {
+    return {
+        iterate: (params?: IterateParams<M>) => paginateFind<M>(find, params, label),
+        findAll: (params?: FindAllParams<M>) => collectAllPages<M>(find, params, label)
+    };
+}

package/src/index.ts

@@ -4,6 +4,7 @@ export * from "./data/buildRebaseData";
 export * from "./data/buildRoutedRebaseData";
 export * from "./data/resolveDataSource";
 export * from "./data/query_builder";
+export * from "./data/paginate";
 export * from "./data/filter-dialect";
 export * from "./data/sort-dialect";
 export * from "./table-classification";

package/src/util/auth-default-policies.ts

@@ -83,9 +83,9 @@ function getIdPropertyName(collection: CollectionConfig): string {
  * Collections that opt out via `disableDefaultPolicies` are returned unchanged.
  */
 export function getEffectiveSecurityRules(collection: CollectionConfig): SecurityRule[] {
-    const explicit = [...((isPostgresCollectionConfig(collection) ? collection.securityRules : undefined) ?? [])];
+    const explicit = [...(collection.securityRules ?? [])];
 
-    if (collection.disableDefaultPolicies) {
+    if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) {
         return explicit;
     }
 
@@ -143,9 +143,9 @@ export function getEffectiveSecurityRules(collection: CollectionConfig): Securit
  * DDL, which policies are injected and how to take them off.
  */
 export function getInjectedSecurityRules(collection: CollectionConfig): SecurityRule[] {
-    if (collection.disableDefaultPolicies) return [];
+    if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) return [];
 
-    const explicitCount = ((isPostgresCollectionConfig(collection) ? collection.securityRules : undefined) ?? []).length;
+    const explicitCount = (collection.securityRules ?? []).length;
     // getEffectiveSecurityRules appends the defaults after the author's rules,
     // so everything past the author's count is injected.
     return getEffectiveSecurityRules(collection).slice(explicitCount);

package/src/util/entities.ts

@@ -247,7 +247,7 @@ export interface RelationRefWithData extends RelationRef {
 }
 
 /**
- * Create a lightweight relation stub for CMS views.
+ * Create a lightweight relation stub for admin views.
  * Replaces inline `{ id, path, __type: "relation" }` object literals.
  */
 export function createRelationRef(id: string | number, path: string): RelationRef {

package/src/util/index.ts

@@ -15,3 +15,4 @@ export * from "./resolve-relation";
 export * from "./auth-default-policies";
 export * from "./junction-policies";
 export * from "./conditions";
+export * from "./pg-column-to-property";

package/src/util/junction-policies.ts

@@ -268,7 +268,7 @@ function coversUpdate(rule: SecurityRule): boolean {
  * stays locked (RLS is still enabled) until they write policies for it.
  */
 export function getJunctionSecurityRules(spec: JunctionSpec): SecurityRule[] {
-    if (spec.declaringSides.every(side => side.collection.disableDefaultPolicies)) {
+    if (spec.declaringSides.every(side => isPostgresCollectionConfig(side.collection) && side.collection.disableDefaultPolicies)) {
         return [];
     }