@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/entries/infrastructure/queries/bulk-publish-preview.query.d.ts

@@ -0,0 +1,19 @@
+import type { AnyContentType } from '../../../types/content-type';
+import { EntryValidationService } from '../../../validation/services/entry-validation.service';
+import type { BulkPublishPreview } from '../../types/bulk-publish';
+import { EntryWriterService } from '../persistence/entry-writer.service';
+/**
+ * The bulk-publish **dry run** — a thin read query. Loads the workspace's live
+ * rows for the requested ids and reports a per-entry verdict (will-publish /
+ * already-published / blocked / not-found) in request order. Writes nothing;
+ * the committed publish (a use-case) re-validates under a `FOR UPDATE` lock and
+ * never trusts this advisory copy.
+ */
+export declare class BulkPublishPreviewQuery {
+    private readonly writer;
+    private readonly validation;
+    constructor(writer: EntryWriterService, validation: EntryValidationService);
+    /** Dry-run a publish over `ids`; 400 on a non-publishable type. */
+    preview(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkPublishPreview>;
+}
+//# sourceMappingURL=bulk-publish-preview.query.d.ts.map

package/dist/lib/entries/infrastructure/queries/bulk-publish-preview.query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-publish-preview.query.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/bulk-publish-preview.query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAC/F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAGzE;;;;;;GAMG;AACH,qBACa,uBAAuB;IAE5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBADV,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,sBAAsB;IAGvD,mEAAmE;IAC7D,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,kBAAkB,CAAC;CAajC"}

package/dist/lib/entries/infrastructure/queries/bulk-publish-preview.query.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkPublishPreviewQuery = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const entry_validation_service_1 = require("../../../validation/services/entry-validation.service");
+const entry_writer_service_1 = require("../persistence/entry-writer.service");
+const bulk_publish_verdicts_1 = require("../persistence/bulk-publish-verdicts");
+/**
+ * The bulk-publish **dry run** — a thin read query. Loads the workspace's live
+ * rows for the requested ids and reports a per-entry verdict (will-publish /
+ * already-published / blocked / not-found) in request order. Writes nothing;
+ * the committed publish (a use-case) re-validates under a `FOR UPDATE` lock and
+ * never trusts this advisory copy.
+ */
+let BulkPublishPreviewQuery = class BulkPublishPreviewQuery {
+    writer;
+    validation;
+    constructor(writer, validation) {
+        this.writer = writer;
+        this.validation = validation;
+    }
+    /** Dry-run a publish over `ids`; 400 on a non-publishable type. */
+    async preview(type, ids, workspaceId) {
+        if (!type.publishable) {
+            throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
+        }
+        const byId = await this.writer.loadLiveByIds(type, ids, workspaceId);
+        return {
+            items: (0, bulk_publish_verdicts_1.computeBulkPublishVerdicts)(type, ids, byId, (t, values) => this.validation.validate(t, values))
+        };
+    }
+};
+exports.BulkPublishPreviewQuery = BulkPublishPreviewQuery;
+exports.BulkPublishPreviewQuery = BulkPublishPreviewQuery = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [entry_writer_service_1.EntryWriterService,
+        entry_validation_service_1.EntryValidationService])
+], BulkPublishPreviewQuery);

package/dist/lib/entries/infrastructure/queries/entries.service.d.ts

@@ -0,0 +1,64 @@
+import { type Database } from '@orthacms/database';
+import { type ContentEntryExtension } from '../../../extension/entry-extension';
+import type { AnyContentType } from '../../../types/content-type';
+import { type ListEntriesQueryDto } from '../../http/dto/list-entries-query.dto';
+import type { EntryListView } from '../../types/entry-list-view';
+import { RelationLinkService } from '../persistence/relation-link.service';
+/**
+ * Reads a collection's entries. Generic over the content type: the physical
+ * table, the filterable columns, the searchable columns, and the sort whitelist
+ * are all derived from `type` at request time, so one service backs every
+ * collection. Owns no schema of its own — it queries the HOST-owned generated
+ * `content_<name>` tables through the shared Drizzle client.
+ */
+export declare class EntriesService {
+    private readonly db;
+    private readonly relationLinks;
+    private readonly extension?;
+    constructor(db: Database, relationLinks: RelationLinkService, extension?: ContentEntryExtension | undefined);
+    /**
+     * One page of a collection's entries: search → filter → sort → paginate, run
+     * in SQL against the type's generated table, returned as the
+     * `{ items, total, page, pageSize }` envelope the admin records table renders.
+     * Scoped to `workspaceId` — only the calling workspace's entries are counted
+     * or listed.
+     */
+    list(type: AnyContentType, query: ListEntriesQueryDto, workspaceId: string): Promise<EntryListView>;
+    /**
+     * The full WHERE: the workspace scope AND free-text search AND the
+     * query-builder `?filter=` tree AND (for paranoid types) the not-deleted
+     * guard. `and(undefined, …)` collapses empties, so an unfiltered list still
+     * scans the workspace's whole table. The workspace predicate is always
+     * present, so an entry never leaks across workspaces. A malformed filter
+     * throws a `FilterException` (HTTP 400).
+     */
+    private listWhere;
+    /**
+     * Translate one `?filter=` payload against the type's filterable surface.
+     * The surface is built per request (content types are code-defined, so it
+     * is pure derivation) and produces BOTH the SQL whitelist used here and
+     * the wire list `/filter-fields` serves — one traversal, so the picker can
+     * never offer a path this rejects. A malformed filter throws a
+     * `FilterException` (HTTP 400).
+     */
+    private filterPredicate;
+    /**
+     * The soft-delete guard for paranoid types: the default list excludes
+     * tombstoned rows (`deleted_at IS NULL`); `?deleted=only` flips to the trash
+     * view (`deleted_at IS NOT NULL`). A non-paranoid type has no `deleted_at`,
+     * so the predicate collapses to `undefined`.
+     */
+    private deletedPredicate;
+    /**
+     * Translate the `?sort=` spec (`col` asc, `-col` desc) into an ORDER BY,
+     * always with an `id` tiebreaker so pagination is stable across requests.
+     * Sortable = the always-present envelope columns + `status` (publishable
+     * only) + the type's **scalar** fields. Non-scalar fields (`json`/
+     * `multiselect`, single/many `relation`) are excluded — a many-relation has
+     * no column on the main table at all, so ordering by it would pass
+     * `undefined` to `asc`/`desc`; the others have no meaningful order. An
+     * unknown or excluded column falls back to `updatedAt` desc.
+     */
+    private orderBy;
+}
+//# sourceMappingURL=entries.service.d.ts.map

package/dist/lib/entries/infrastructure/queries/entries.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.service.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/entries.service.ts"],"names":[],"mappings":"AAYA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnE,OAAO,EAEH,KAAK,qBAAqB,EAE7B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EAGH,KAAK,mBAAmB,EAC3B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAMjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AA+B3E;;;;;;GAMG;AACH,qBACa,cAAc;IAED,OAAO,CAAC,QAAQ,CAAC,EAAE;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAK9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;gBANQ,EAAE,EAAE,QAAQ,EAC9B,aAAa,EAAE,mBAAmB,EAKlC,SAAS,CAAC,EAAE,qBAAqB,YAAA;IAGtD;;;;;;OAMG;IACG,IAAI,CACN,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,mBAAmB,EAC1B,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC;IAgDzB;;;;;;;OAOG;YACW,SAAS;IA0CvB;;;;;;;OAOG;YACW,eAAe;IAyB7B;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO;CAsBlB"}

package/dist/lib/entries/infrastructure/queries/entries.service.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntriesService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const utils_server_1 = require("@orthacms/utils-server");
+const entry_extension_1 = require("../../../extension/entry-extension");
+const fields_1 = require("../../../types/fields");
+const list_entries_query_dto_1 = require("../../http/dto/list-entries-query.dto");
+const entries_constants_1 = require("../../entries.constants");
+const entry_scalar_fields_1 = require("./entry-scalar-fields");
+const entry_filter_surface_1 = require("./entry-filter-surface");
+const entry_search_1 = require("./entry-search");
+const entry_row_1 = require("../persistence/entry-row");
+const relation_link_service_1 = require("../persistence/relation-link.service");
+/**
+ * The relation fields a `?relationFields=` list actually names, intersected with
+ * the type's own relation fields. Unknown names are dropped, so a client string
+ * never reaches a query — only keys already present on `type.fields` survive.
+ */
+function previewFields(type, raw) {
+    if (!raw)
+        return [];
+    const wanted = new Set(raw
+        .split(',')
+        .map((name) => name.trim())
+        .filter(Boolean));
+    return Object.entries(type.fields)
+        .filter(([name, spec]) => wanted.has(name) &&
+        spec.type === fields_1.CONTENT_FIELD_TYPE.Relation &&
+        !!spec.relation)
+        .map(([name]) => name);
+}
+/**
+ * Reads a collection's entries. Generic over the content type: the physical
+ * table, the filterable columns, the searchable columns, and the sort whitelist
+ * are all derived from `type` at request time, so one service backs every
+ * collection. Owns no schema of its own — it queries the HOST-owned generated
+ * `content_<name>` tables through the shared Drizzle client.
+ */
+let EntriesService = class EntriesService {
+    db;
+    relationLinks;
+    extension;
+    constructor(db, relationLinks, extension) {
+        this.db = db;
+        this.relationLinks = relationLinks;
+        this.extension = extension;
+    }
+    /**
+     * One page of a collection's entries: search → filter → sort → paginate, run
+     * in SQL against the type's generated table, returned as the
+     * `{ items, total, page, pageSize }` envelope the admin records table renders.
+     * Scoped to `workspaceId` — only the calling workspace's entries are counted
+     * or listed.
+     */
+    async list(type, query, workspaceId) {
+        const page = query.page ?? 1;
+        const pageSize = query.pageSize ?? entries_constants_1.DEFAULT_PAGE_SIZE;
+        const where = await this.listWhere(type, query, workspaceId);
+        const orderBy = this.orderBy(type, query.sort);
+        // Count and page rows share the WHERE but are independent — run them
+        // concurrently so the request pays the slower of the two, not their sum.
+        const [[{ total }], rows] = await Promise.all([
+            this.db.select({ total: (0, drizzle_orm_1.count)() }).from(type.table).where(where),
+            this.db
+                .select()
+                .from(type.table)
+                .where(where)
+                .orderBy(...orderBy)
+                .limit(pageSize)
+                .offset((page - 1) * pageSize)
+        ]);
+        const items = rows.map((row) => (0, entry_row_1.toRecord)(type, row));
+        // Opt-in relation preview for the records table's visible relation
+        // columns. Batched across the whole page (a constant number of queries
+        // per field), so this never becomes an N+1 over rows — see
+        // `previewForEntries`. Off by default: the relation picker reuses this
+        // endpoint for candidates and must not pay for it.
+        if (query.relations === list_entries_query_dto_1.RELATIONS_PREVIEW && items.length) {
+            const fields = previewFields(type, query.relationFields);
+            if (fields.length) {
+                const previews = await this.relationLinks.previewForEntries(type, fields, rows, workspaceId);
+                for (const item of items) {
+                    const preview = previews.get(item.id);
+                    if (preview)
+                        item.relations = preview;
+                }
+            }
+        }
+        return { items, total, page, pageSize };
+    }
+    /**
+     * The full WHERE: the workspace scope AND free-text search AND the
+     * query-builder `?filter=` tree AND (for paranoid types) the not-deleted
+     * guard. `and(undefined, …)` collapses empties, so an unfiltered list still
+     * scans the workspace's whole table. The workspace predicate is always
+     * present, so an entry never leaks across workspaces. A malformed filter
+     * throws a `FilterException` (HTTP 400).
+     */
+    async listWhere(type, query, workspaceId) {
+        // The bound extension may contribute virtual filter fields (declared
+        // into the schema, resolved to its own SQL) and an extra scope
+        // predicate (e.g. the active locale). Both are no-ops for types the
+        // extension doesn't apply to.
+        const filterExtension = this.extension?.filterExtension(type);
+        // Building the surface walks the type's whole relation graph to the
+        // hop budget, so only pay for it when there is actually a filter to
+        // translate — an unfiltered list (the common case) skips it entirely.
+        //
+        // `grantedTypes` is deliberately left unset: this is the SQL
+        // whitelist, not a visibility boundary, and pruning it by grant would
+        // make the *same* saved filter 400 or silently change meaning
+        // depending on which workspace opened it. Grant pruning belongs on
+        // the `/filter-fields` surface the picker renders, where it is
+        // applied. Every relation subquery is workspace-scoped regardless, so
+        // a traversal can never read another workspace's rows.
+        const filterSql = query.filter
+            ? await this.filterPredicate(type, query.filter, workspaceId, filterExtension)
+            : undefined;
+        const table = type.table;
+        return (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(table['workspaceId'], workspaceId), this.extension?.listScope(type, workspaceId, {
+            locale: query.locale,
+            localeFallback: query.localeFallback
+        }), (0, entry_search_1.buildSearchPredicate)(type, query.search), filterSql, this.deletedPredicate(type, query));
+    }
+    /**
+     * Translate one `?filter=` payload against the type's filterable surface.
+     * The surface is built per request (content types are code-defined, so it
+     * is pure derivation) and produces BOTH the SQL whitelist used here and
+     * the wire list `/filter-fields` serves — one traversal, so the picker can
+     * never offer a path this rejects. A malformed filter throws a
+     * `FilterException` (HTTP 400).
+     */
+    async filterPredicate(type, filter, workspaceId, filterExtension) {
+        const { schema } = (0, entry_filter_surface_1.buildEntryFilterSurface)(type, {
+            workspaceId,
+            extensionFields: filterExtension?.fields
+        });
+        const tree = (0, utils_server_1.parseFilterTree)(filter, schema);
+        return (0, utils_server_1.applyFilterTree)(tree, schema, type.table, this.db, filterExtension
+            ? {
+                resolveExtension: (rule) => filterExtension.resolve(rule, { type, workspaceId })
+            }
+            : {});
+    }
+    /**
+     * The soft-delete guard for paranoid types: the default list excludes
+     * tombstoned rows (`deleted_at IS NULL`); `?deleted=only` flips to the trash
+     * view (`deleted_at IS NOT NULL`). A non-paranoid type has no `deleted_at`,
+     * so the predicate collapses to `undefined`.
+     */
+    deletedPredicate(type, query) {
+        if (!type.paranoid)
+            return undefined;
+        const table = type.table;
+        return query.deleted === list_entries_query_dto_1.DELETED_ONLY
+            ? (0, drizzle_orm_1.isNotNull)(table['deletedAt'])
+            : (0, drizzle_orm_1.isNull)(table['deletedAt']);
+    }
+    /**
+     * Translate the `?sort=` spec (`col` asc, `-col` desc) into an ORDER BY,
+     * always with an `id` tiebreaker so pagination is stable across requests.
+     * Sortable = the always-present envelope columns + `status` (publishable
+     * only) + the type's **scalar** fields. Non-scalar fields (`json`/
+     * `multiselect`, single/many `relation`) are excluded — a many-relation has
+     * no column on the main table at all, so ordering by it would pass
+     * `undefined` to `asc`/`desc`; the others have no meaningful order. An
+     * unknown or excluded column falls back to `updatedAt` desc.
+     */
+    orderBy(type, sort) {
+        const table = type.table;
+        const sortable = new Set([
+            'createdAt',
+            'updatedAt',
+            ...(type.publishable ? ['status'] : []),
+            ...(type.i18n ? ['locale'] : []),
+            ...Object.entries(type.fields)
+                .filter(([, spec]) => (0, entry_scalar_fields_1.isScalarField)(spec))
+                .map(([name]) => name)
+        ]);
+        const isDesc = !!sort && sort.startsWith('-');
+        const columnId = sort ? (isDesc ? sort.slice(1) : sort) : '';
+        // The whitelist only admits scalar columns, but guard against a missing
+        // column defensively so a sort key never reaches `asc(undefined)`.
+        const col = sortable.has(columnId) ? table[columnId] : undefined;
+        if (col) {
+            return [isDesc ? (0, drizzle_orm_1.desc)(col) : (0, drizzle_orm_1.asc)(col), (0, drizzle_orm_1.asc)(table['id'])];
+        }
+        return [(0, drizzle_orm_1.desc)(table['updatedAt']), (0, drizzle_orm_1.asc)(table['id'])];
+    }
+};
+exports.EntriesService = EntriesService;
+exports.EntriesService = EntriesService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__param(2, (0, common_1.Optional)()),
+    tslib_1.__param(2, (0, common_1.Inject)(entry_extension_1.CONTENT_ENTRY_EXTENSION)),
+    tslib_1.__metadata("design:paramtypes", [Object, relation_link_service_1.RelationLinkService, Object])
+], EntriesService);

package/dist/lib/entries/infrastructure/queries/entry-filter-schema.d.ts

@@ -0,0 +1,40 @@
+import { type FieldSchema, type FilterSchema, type ScalarFieldSchema } from '@ortha-cms/utils-server';
+import { type AnyContentType } from '../../../types/content-type';
+import { type AnyFieldSpec } from '../../../types/fields';
+/**
+ * The filter scalar type for one content field, or `null` to leave it
+ * unfilterable. Mirrors the admin's `filterFieldsFromSchema`: text-like fields
+ * filter as strings, `select` as an enum of its options, numerics as numbers,
+ * dates as dates. `json`/`multiselect` have no scalar editor, and `relation`
+ * filtering (by raw FK uuid) has no UI yet — all skipped.
+ */
+export declare function scalarTypeFor(spec: AnyFieldSpec): ScalarFieldSchema | null;
+/**
+ * Whether a field is backed by a comparable scalar column — the single source of
+ * truth for "can this field be filtered or sorted". `json`/`multiselect` (jsonb)
+ * and `relation` (FK uuid / join table) are not: they have no scalar editor and
+ * ordering them is meaningless. The sort whitelist and the filter schema both
+ * derive from this, so the two can't drift apart.
+ */
+export declare function isScalarField(spec: AnyFieldSpec): boolean;
+/**
+ * Build the query-builder `FilterSchema` for one content type at request time.
+ * Whitelists the always-present envelope columns (`createdAt`/`updatedAt`),
+ * plus `status`/`publishedAt` only on publishable types, plus `locale` on i18n
+ * types, plus every filterable field (those `isScalarField` admits — the same
+ * set the admin's `filterFieldsFromSchema` offers), keyed by the property
+ * names the engine resolves to table columns. (`status` has a matching admin
+ * filter; the timestamp envelopes like `publishedAt` are filterable via the
+ * API but have no UI control yet.) This is the security boundary: only listed
+ * fields/ops reach SQL, and the engine's depth/node caps bound payload
+ * blow-up.
+ *
+ * `extensionFields` are **virtual** fields contributed by the bound
+ * `CONTENT_ENTRY_EXTENSION` (e.g. locale aggregates): their declarations merge
+ * into `fields` (so the parser can coerce values) and their names are
+ * registered on the schema's `extensionFields` set, routing them to the
+ * extension's own SQL resolver instead of a table column. A field column
+ * always wins a name collision — an extension cannot shadow real data.
+ */
+export declare function buildEntryFilterSchema(type: AnyContentType, extensionFields?: FieldSchema): FilterSchema;
+//# sourceMappingURL=entry-filter-schema.d.ts.map

package/dist/lib/entries/infrastructure/queries/entry-filter-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-filter-schema.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/entry-filter-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE9E;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,iBAAiB,GAAG,IAAI,CAsB1E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,cAAc,EACpB,eAAe,CAAC,EAAE,WAAW,GAC9B,YAAY,CAmCd"}

package/dist/lib/entries/infrastructure/queries/entry-filter-surface.d.ts

@@ -0,0 +1,38 @@
+import { type FieldSchema, type FilterSchema } from '@orthacms/utils-server';
+import { type AnyContentType } from '../../../types/content-type';
+import type { WireFilterField } from '../../types/filter-surface';
+/** Options for {@link buildEntryFilterSurface}. */
+export interface FilterSurfaceOptions {
+    /** Request workspace — scopes every relation subquery. */
+    workspaceId: string;
+    /** Extension-contributed virtual filter fields (locale aggregates, …). */
+    extensionFields?: FieldSchema;
+    /**
+     * Content-type names granted to this workspace. A relation whose target
+     * is not granted is omitted entirely — mirroring the entry editor's
+     * `availableTypeNames`, so the filter picker never offers a traversal
+     * into a collection the caller cannot see. When absent, no pruning.
+     */
+    grantedTypes?: ReadonlySet<string>;
+    /** Override the default relation-hop budget. */
+    maxRelationHops?: number;
+}
+/**
+ * The filterable surface for one content type: the Drizzle `FilterSchema`
+ * (the security boundary — only listed paths reach SQL) AND the flat
+ * `WireFilterField[]` the admin's query builder renders, produced by a
+ * single traversal so they cannot drift.
+ *
+ * `extensionFields` are virtual fields contributed by the bound
+ * `CONTENT_ENTRY_EXTENSION` (locale aggregates, …): they merge into the
+ * root `fields` (so the parser can coerce their values) and their names are
+ * registered on `extensionFields` (so the translator routes them to the
+ * extension's own SQL resolver). A real column always wins a name clash.
+ * They are NOT surfaced as wire fields here — a contributing plugin adds
+ * those via the admin's `RECORDS_FILTER_FIELDS_SLOT`, as today.
+ */
+export declare function buildEntryFilterSurface(type: AnyContentType, opts: FilterSurfaceOptions): {
+    schema: FilterSchema;
+    fields: WireFilterField[];
+};
+//# sourceMappingURL=entry-filter-surface.d.ts.map

package/dist/lib/entries/infrastructure/queries/entry-filter-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-filter-surface.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/entry-filter-surface.ts"],"names":[],"mappings":"AAEA,OAAO,EAIH,KAAK,WAAW,EAChB,KAAK,YAAY,EAIpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAgBlE,mDAAmD;AACnD,MAAM,WAAW,oBAAoB;IACjC,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,eAAe,CAAC,EAAE,WAAW,CAAC;IAC9B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnC,gDAAgD;IAChD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAsTD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,oBAAoB,GAC3B;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CA6BrD"}