@orthacms/content-server 0.4.2 → 0.4.3

package/dist/lib/entries/infrastructure/queries/entry-match.query.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryMatchQuery = 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 entry_filter_provider_1 = require("../../../extension/entry-filter-provider");
+const entry_filter_surface_1 = require("./entry-filter-surface");
+/**
+ * Answers "which entries of this type match this filter?" against the same
+ * surface, parser and translator the records list uses.
+ *
+ * It exists so a downstream plugin can reuse content's filter semantics
+ * without reaching for the database or rebuilding the surface: the filterable
+ * paths, the relation-hop budget, the workspace scoping of every relation
+ * subquery, and the 400 on a malformed tree are all inherited rather than
+ * re-implemented. `@orthacms/alarms-server` evaluates its rules through this,
+ * which is what makes "the rule I saved from the list means what the list
+ * showed me" true by construction rather than by review.
+ *
+ * Two deliberate differences from the list query:
+ *
+ * - **No locale scoping.** The entries extension's `listScope` narrows a list
+ *   to the active locale; a rule is a statement about the collection, so it
+ *   must see every translation. The extension's *virtual filter fields* are
+ *   still wired, so a rule may filter on them explicitly.
+ * - **Trashed rows are excluded, always.** There is no trash view here, and a
+ *   tombstoned row is not something anyone can act on.
+ */
+let EntryMatchQuery = class EntryMatchQuery {
+    db;
+    filterProviders;
+    extension;
+    constructor(db, 
+    // Same pair as `EntriesService`: an alarm rule stores the records
+    // list's filter verbatim, so it has to parse against exactly the
+    // surface that list offers — including the fields other plugins add.
+    filterProviders, extension) {
+        this.db = db;
+        this.filterProviders = filterProviders;
+        this.extension = extension;
+    }
+    /**
+     * Parses `filter` against `type`'s surface without running it, throwing a
+     * `FilterException` when it does not hold up. Callers store filters that
+     * will be replayed by a background subscriber for months, so the parse
+     * belongs at the moment the filter is written — a tree that only fails at
+     * evaluation time fails somewhere nobody is looking.
+     */
+    assertParses(type, filter, workspaceId) {
+        const { schema } = (0, entry_filter_surface_1.buildEntryFilterSurface)(type, {
+            workspaceId,
+            extensionFields: this.filterProviders.compose(type, this.extension?.filterExtension(type))?.fields
+        });
+        (0, utils_server_1.parseFilterTree)(filter, schema);
+    }
+    /**
+     * Ids of `type` in `workspaceId` matching `filter`, oldest-id first so a
+     * batched scan is stable across calls.
+     */
+    async matchingIds(type, filter, workspaceId, options = {}) {
+        // An empty restriction means "none of them", not "all of them" — an
+        // `inArray(col, [])` would be a false predicate anyway, but returning
+        // early keeps a caller that batched its ids from paying for a query
+        // whose answer is known.
+        if (options.entryIds && options.entryIds.length === 0)
+            return [];
+        const where = await this.predicate(type, filter, workspaceId, options);
+        const table = type.table;
+        const rows = await this.db
+            .select({ id: table['id'] })
+            .from(type.table)
+            .where(where)
+            .orderBy(table['id'])
+            .limit(options.limit ?? Number.MAX_SAFE_INTEGER)
+            .offset(options.offset ?? 0);
+        return rows.map((row) => String(row.id));
+    }
+    /** How many entries of `type` match `filter` right now. */
+    async countMatching(type, filter, workspaceId) {
+        const where = await this.predicate(type, filter, workspaceId, {});
+        const [row] = await this.db
+            .select({ total: (0, drizzle_orm_1.count)() })
+            .from(type.table)
+            .where(where);
+        return Number(row?.total ?? 0);
+    }
+    /**
+     * How many entries of `type` the workspace holds at all — the denominator
+     * the rule editor shows beside a match count ("14 of 312"), which is what
+     * turns a number into a judgement about whether the rule is too broad.
+     */
+    async countAll(type, workspaceId) {
+        const [row] = await this.db
+            .select({ total: (0, drizzle_orm_1.count)() })
+            .from(type.table)
+            .where(this.scope(type, workspaceId));
+        return Number(row?.total ?? 0);
+    }
+    /**
+     * The workspace an entry belongs to, or `null` when no such row exists.
+     *
+     * A domain event names an entry and its content type but not its workspace
+     * — every content table carries its own `workspace_id`, so there is nothing
+     * for the envelope to add that a one-column lookup cannot answer. Exposed
+     * here rather than left to each subscriber, so a downstream plugin never
+     * has a reason to query a `content_<name>` table directly.
+     */
+    async workspaceOf(type, entryId) {
+        const table = type.table;
+        const [row] = await this.db
+            .select({ workspaceId: table['workspaceId'] })
+            .from(type.table)
+            .where((0, drizzle_orm_1.eq)(table['id'], entryId))
+            .limit(1);
+        return row?.workspaceId ? String(row.workspaceId) : null;
+    }
+    /** The workspace + not-trashed guard every scan starts from. */
+    scope(type, workspaceId) {
+        const table = type.table;
+        return (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(table['workspaceId'], workspaceId), type.paranoid ? (0, drizzle_orm_1.isNull)(table['deletedAt']) : undefined);
+    }
+    /** Scope + translated filter + optional id restriction. */
+    async predicate(type, filter, workspaceId, options) {
+        const filterExtension = this.filterProviders.compose(type, this.extension?.filterExtension(type));
+        const { schema } = (0, entry_filter_surface_1.buildEntryFilterSurface)(type, {
+            workspaceId,
+            extensionFields: filterExtension?.fields
+        });
+        const tree = (0, utils_server_1.parseFilterTree)(filter, schema);
+        const filterSql = await (0, utils_server_1.applyFilterTree)(tree, schema, type.table, this.db, filterExtension
+            ? {
+                resolveExtension: (rule) => filterExtension.resolve(rule, { type, workspaceId })
+            }
+            : {});
+        const table = type.table;
+        return (0, drizzle_orm_1.and)(this.scope(type, workspaceId), filterSql, options.entryIds
+            ? (0, drizzle_orm_1.inArray)(table['id'], [...options.entryIds])
+            : undefined);
+    }
+};
+exports.EntryMatchQuery = EntryMatchQuery;
+exports.EntryMatchQuery = EntryMatchQuery = 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, entry_filter_provider_1.EntryFilterProviderRegistry, Object])
+], EntryMatchQuery);

package/dist/lib/extension/entry-access-source.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The **entry-access description port** — the seam a downstream plugin uses to
+ * tell a protocol adapter *that* an entry it just served is restricted, without
+ * this package knowing what a restriction is.
+ *
+ * It is the read scope's opposite number and deliberately not the same thing.
+ * `CONTENT_READ_SCOPE` decides which rows a reader gets; this describes the rows
+ * they got. A scope can only subtract, so by the time an annotation is asked
+ * for, the entry has already been admitted — which is why nothing here can
+ * refuse anything, and why an implementation that returned nothing would be a
+ * missing label rather than a leak.
+ *
+ * ## What it is for
+ *
+ * One thing, and it is worth being blunt about it: **a restricted entry must not
+ * be cached as public.** A CDN, a shared HTTP cache or a client store that keeps
+ * one reader's copy and hands it to the next turns a working entitlement into a
+ * data leak, and nothing else in the response says the entry was reader-scoped —
+ * it looks exactly like an open one. Everything else an implementation could
+ * report (who exactly may read it, which segments) is a question for the admin
+ * API, where the caller is a member of the workspace rather than a consumer of
+ * its content.
+ *
+ * ## Why a registry rather than a DI token
+ *
+ * The same reason the read scope uses one: Nest has **no multi-provider**, so
+ * two dynamic modules binding one token do not merge — the second silently
+ * replaces the first. Here that would mean an entry that one plugin knows is
+ * restricted reported as open because a second plugin was registered after it,
+ * which is precisely the mislabelling this port exists to prevent. Registration
+ * is a runtime `register(...)` call, the same shape as
+ * {@link contentReadScopeRegistrar}.
+ *
+ * ## The batching constraint
+ *
+ * `describe` takes the whole page of entry ids, not one. A protocol adapter
+ * resolves a list and then labels it; asking per entry would be a query per row
+ * on a path whose cost is otherwise one page read. An implementation that cannot
+ * answer for an id simply leaves it out of the map, and the caller reads a
+ * missing key as unrestricted — the same default absence carries everywhere
+ * else in this feature.
+ */
+import { type Provider, type Type } from '@nestjs/common';
+/** What one entry's restriction looks like from outside the plugin that owns it. */
+export interface EntryAccessDescription {
+    /**
+     * Whether anything narrowed who may read this entry.
+     *
+     * `true` means the response is reader-specific and must not be stored in a
+     * shared cache without varying on whatever identifies the reader.
+     */
+    readonly restricted: boolean;
+    /**
+     * The axes that took part, as opaque keys (`org`, `plan`). A hint for a
+     * client deciding what to vary its own cache on — never the segments
+     * themselves, which would tell a consumer who *else* may read the entry.
+     */
+    readonly dimensions: readonly string[];
+}
+/** What a source is told about the page it is describing. */
+export interface EntryAccessQuery {
+    /** The workspace the entries were read in. */
+    readonly workspaceId: string;
+    /** The ids to describe. Never empty — the caller skips an empty page. */
+    readonly entryIds: readonly string[];
+}
+/**
+ * One contributed description of what was served.
+ *
+ * Returning an empty map means "nothing to say about this page", which is what
+ * an installed-but-unconfigured plugin returns and what every entry defaults to.
+ */
+export interface EntryAccessSource {
+    /** Describes the given entries, keyed by entry id. Ids may be omitted. */
+    describe(query: EntryAccessQuery): Promise<ReadonlyMap<string, EntryAccessDescription>>;
+}
+/**
+ * Every registered source, merged.
+ *
+ * The merge is a **union that can only tighten**: an entry is restricted if any
+ * source says so, and the dimensions are the union of what each reported. Two
+ * plugins narrowing reads for different reasons both need to be heard, and the
+ * safe direction for a disagreement is the one that keeps a shared cache from
+ * storing the entry.
+ */
+export declare class EntryAccessSourceRegistry {
+    private readonly sources;
+    /** Adds a source. Registering the same instance twice is a no-op. */
+    register(source: EntryAccessSource): void;
+    /** Whether anything is registered — the cheap check before building a page. */
+    get active(): boolean;
+    /**
+     * Describes one page of entries.
+     *
+     * Returns an empty map when nothing is registered or the page is empty, so
+     * a caller on an installation with no scoping plugin does no work and every
+     * entry reads as unrestricted.
+     */
+    describe(query: EntryAccessQuery): Promise<ReadonlyMap<string, EntryAccessDescription>>;
+}
+/**
+ * Builds the DI provider that registers `sources` with content's access-source
+ * registry at bootstrap.
+ *
+ * A factory with an explicit `inject` list rather than a class with reflected
+ * parameters, for the reason `contentReadScopeRegistrar` documents: an optional
+ * dependency typed as `Foo | null` emits `Object` for `design:paramtypes`, Nest
+ * injects `undefined` with no error, and the plugin ends up registering
+ * nothing.
+ */
+export declare function entryAccessSourceRegistrar(label: string, ...sources: Type<EntryAccessSource>[]): Provider;
+//# sourceMappingURL=entry-access-source.d.ts.map

package/dist/lib/extension/entry-access-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-access-source.d.ts","sourceRoot":"","sources":["../../../src/lib/extension/entry-access-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAIH,KAAK,QAAQ,EACb,KAAK,IAAI,EACZ,MAAM,gBAAgB,CAAC;AAExB,oFAAoF;AACpF,MAAM,WAAW,sBAAsB;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,6DAA6D;AAC7D,MAAM,WAAW,gBAAgB;IAC7B,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAC9B,0EAA0E;IAC1E,QAAQ,CACJ,KAAK,EAAE,gBAAgB,GACxB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC,CAAC;CAC3D;AAED;;;;;;;;GAQG;AACH,qBACa,yBAAyB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IAEnD,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAMzC,+EAA+E;IAC/E,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;;;;OAMG;IACG,QAAQ,CACV,KAAK,EAAE,gBAAgB,GACxB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CAgC1D;AA4BD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACtC,KAAK,EAAE,MAAM,EACb,GAAG,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,EAAE,GACtC,QAAQ,CAYV"}

package/dist/lib/extension/entry-filter-provider.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The **virtual filter-field registry** — how more than one plugin contributes
+ * fields to a content type's `?filter=` surface.
+ *
+ * `CONTENT_ENTRY_EXTENSION.filterExtension` already declares virtual fields
+ * (i18n's `hasLocale` / `missingLocale` / `localeCount`), but that port is a
+ * documented **single binding**: one provider per app, and i18n holds it. Nest
+ * has no multi-provider, so a second plugin binding the token would silently
+ * replace the first — for a filter surface that means fields quietly vanishing
+ * from the picker and saved filters starting to 400.
+ *
+ * So a plugin registers here instead (`@orthacms/segments-server` contributes
+ * "can be seen by" / "cannot be seen by" / "restricted"), the same shape and the
+ * same reason as `contentReadScopeRegistrar`. The bound extension keeps its
+ * method; {@link EntryFilterProviderRegistry.compose} folds the two together
+ * into the one `EntryFilterExtension` the query path already knows how to use,
+ * so nothing downstream changed.
+ *
+ * ## What a contribution owes
+ *
+ * **Every emitted subquery MUST scope to the workspace it is handed.** A virtual
+ * field is a subquery over a table this package knows nothing about; one that
+ * forgets the workspace turns a filter into a cross-tenant read.
+ *
+ * **Only declare fields you can answer, with only the operators you support.**
+ * The declared `fields` become the SQL whitelist, so an operator the resolver
+ * refuses reaches the user as "couldn't load this collection" over a rule the
+ * picker itself proposed. Narrow the operator set in the admin's `FilterField`
+ * to match.
+ *
+ * **A filter narrows what is listed; it is not a visibility rule.** Reachability
+ * is `CONTENT_READ_SCOPE`'s job and is applied separately. A field here must not
+ * be relied on to hide anything.
+ */
+import { type Provider, type Type } from '@nestjs/common';
+import type { AnyContentType } from '../types/content-type';
+import type { EntryFilterExtension } from './entry-extension';
+/** One plugin's virtual filter fields. */
+export interface EntryFilterProvider {
+    /**
+     * The fields this plugin adds to `type`'s filter surface, or `undefined`
+     * when it adds none — which is what a plugin that is installed but
+     * unconfigured must return, so a bare install pays nothing.
+     */
+    filterFor(type: AnyContentType): EntryFilterExtension | undefined;
+}
+/** Every registered provider, in registration order. */
+export declare class EntryFilterProviderRegistry {
+    private readonly logger;
+    private readonly providers;
+    /** Adds a provider. Registering the same instance twice is a no-op. */
+    register(provider: EntryFilterProvider): void;
+    /**
+     * Fold the bound extension's contribution and every registered provider's
+     * into one {@link EntryFilterExtension}.
+     *
+     * Returns `undefined` when nobody contributed anything, so a type with no
+     * virtual fields builds exactly the surface it did before this registry
+     * existed — and `entries.service` keeps its "no extension, no
+     * `resolveExtension`" branch.
+     *
+     * `resolve` routes by the rule's **field name**, to whoever declared it.
+     * A name declared twice is kept by its first declarer and the duplicate is
+     * dropped with a warning: silently letting the last writer win would make
+     * the meaning of a saved filter depend on plugin registration order.
+     */
+    compose(type: AnyContentType, bound: EntryFilterExtension | undefined): EntryFilterExtension | undefined;
+}
+/**
+ * Builds the DI provider that registers `providers` with content's filter-field
+ * registry at bootstrap.
+ *
+ * A factory with an explicit `inject` list rather than a class with reflected
+ * parameters, for the reason `contentReadScopeRegistrar` documents: an optional
+ * dependency typed `Foo | null` emits `Object` for `design:paramtypes`, Nest
+ * injects `undefined` with no error, and the plugin registers nothing.
+ */
+export declare function entryFilterProviderRegistrar(label: string, ...providers: Type<EntryFilterProvider>[]): Provider;
+//# sourceMappingURL=entry-filter-provider.d.ts.map

package/dist/lib/extension/entry-filter-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-filter-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/extension/entry-filter-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAIH,KAAK,QAAQ,EACb,KAAK,IAAI,EACZ,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,0CAA0C;AAC1C,MAAM,WAAW,mBAAmB;IAChC;;;;OAIG;IACH,SAAS,CAAC,IAAI,EAAE,cAAc,GAAG,oBAAoB,GAAG,SAAS,CAAC;CACrE;AAED,wDAAwD;AACxD,qBACa,2BAA2B;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgD;IACvE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IAEvD,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAM7C;;;;;;;;;;;;;OAaG;IACH,OAAO,CACH,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAAG,SAAS,GACxC,oBAAoB,GAAG,SAAS;CAyCtC;AA0BD;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CACxC,KAAK,EAAE,MAAM,EACb,GAAG,SAAS,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAE,GAC1C,QAAQ,CAYV"}

package/dist/lib/extension/entry-filter-provider.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * The **virtual filter-field registry** — how more than one plugin contributes
+ * fields to a content type's `?filter=` surface.
+ *
+ * `CONTENT_ENTRY_EXTENSION.filterExtension` already declares virtual fields
+ * (i18n's `hasLocale` / `missingLocale` / `localeCount`), but that port is a
+ * documented **single binding**: one provider per app, and i18n holds it. Nest
+ * has no multi-provider, so a second plugin binding the token would silently
+ * replace the first — for a filter surface that means fields quietly vanishing
+ * from the picker and saved filters starting to 400.
+ *
+ * So a plugin registers here instead (`@orthacms/segments-server` contributes
+ * "can be seen by" / "cannot be seen by" / "restricted"), the same shape and the
+ * same reason as `contentReadScopeRegistrar`. The bound extension keeps its
+ * method; {@link EntryFilterProviderRegistry.compose} folds the two together
+ * into the one `EntryFilterExtension` the query path already knows how to use,
+ * so nothing downstream changed.
+ *
+ * ## What a contribution owes
+ *
+ * **Every emitted subquery MUST scope to the workspace it is handed.** A virtual
+ * field is a subquery over a table this package knows nothing about; one that
+ * forgets the workspace turns a filter into a cross-tenant read.
+ *
+ * **Only declare fields you can answer, with only the operators you support.**
+ * The declared `fields` become the SQL whitelist, so an operator the resolver
+ * refuses reaches the user as "couldn't load this collection" over a rule the
+ * picker itself proposed. Narrow the operator set in the admin's `FilterField`
+ * to match.
+ *
+ * **A filter narrows what is listed; it is not a visibility rule.** Reachability
+ * is `CONTENT_READ_SCOPE`'s job and is applied separately. A field here must not
+ * be relied on to hide anything.
+ */
+var EntryFilterProviderRegistry_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryFilterProviderRegistry = void 0;
+exports.entryFilterProviderRegistrar = entryFilterProviderRegistrar;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+/** Every registered provider, in registration order. */
+let EntryFilterProviderRegistry = EntryFilterProviderRegistry_1 = class EntryFilterProviderRegistry {
+    logger = new common_1.Logger(EntryFilterProviderRegistry_1.name);
+    providers = [];
+    /** Adds a provider. Registering the same instance twice is a no-op. */
+    register(provider) {
+        if (!this.providers.includes(provider)) {
+            this.providers.push(provider);
+        }
+    }
+    /**
+     * Fold the bound extension's contribution and every registered provider's
+     * into one {@link EntryFilterExtension}.
+     *
+     * Returns `undefined` when nobody contributed anything, so a type with no
+     * virtual fields builds exactly the surface it did before this registry
+     * existed — and `entries.service` keeps its "no extension, no
+     * `resolveExtension`" branch.
+     *
+     * `resolve` routes by the rule's **field name**, to whoever declared it.
+     * A name declared twice is kept by its first declarer and the duplicate is
+     * dropped with a warning: silently letting the last writer win would make
+     * the meaning of a saved filter depend on plugin registration order.
+     */
+    compose(type, bound) {
+        const contributions = [
+            ...(bound ? [bound] : []),
+            ...this.providers
+                .map((provider) => provider.filterFor(type))
+                .filter((entry) => !!entry)
+        ];
+        if (!contributions.length)
+            return undefined;
+        if (contributions.length === 1)
+            return contributions[0];
+        const fields = {};
+        const owners = new Map();
+        for (const contribution of contributions) {
+            for (const [name, spec] of Object.entries(contribution.fields)) {
+                if (owners.has(name)) {
+                    this.logger.warn(`Two plugins declare the filter field "${name}" on "${type.name}"; keeping the first.`);
+                    continue;
+                }
+                owners.set(name, contribution);
+                fields[name] = spec;
+            }
+        }
+        return {
+            fields,
+            resolve: (rule, context) => {
+                const owner = owners.get(rule.path[0]);
+                if (!owner) {
+                    // Unreachable through the parser — a rule only gets here
+                    // after its name was whitelisted from `fields` above — but a
+                    // thrown error beats a silently-true predicate if it ever is.
+                    throw new Error(`No provider owns the filter field "${rule.path[0]}".`);
+                }
+                return owner.resolve(rule, context);
+            }
+        };
+    }
+};
+exports.EntryFilterProviderRegistry = EntryFilterProviderRegistry;
+exports.EntryFilterProviderRegistry = EntryFilterProviderRegistry = EntryFilterProviderRegistry_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], EntryFilterProviderRegistry);
+/** Registers a plugin's filter providers with content at bootstrap. */
+class EntryFilterBootstrapper {
+    label;
+    registry;
+    providers;
+    logger = new common_1.Logger(EntryFilterBootstrapper.name);
+    constructor(label, registry, providers) {
+        this.label = label;
+        this.registry = registry;
+        this.providers = providers;
+    }
+    onApplicationBootstrap() {
+        // A deployment without `ContentPlugin` is not a real configuration, but
+        // a binding plugin should still boot rather than fail on an injection it
+        // cannot influence.
+        if (!this.registry)
+            return;
+        for (const provider of this.providers) {
+            this.registry.register(provider);
+        }
+        this.logger.log(`Registered the ${this.label} filter fields with content.`);
+    }
+}
+/**
+ * Builds the DI provider that registers `providers` with content's filter-field
+ * registry at bootstrap.
+ *
+ * A factory with an explicit `inject` list rather than a class with reflected
+ * parameters, for the reason `contentReadScopeRegistrar` documents: an optional
+ * dependency typed `Foo | null` emits `Object` for `design:paramtypes`, Nest
+ * injects `undefined` with no error, and the plugin registers nothing.
+ */
+function entryFilterProviderRegistrar(label, ...providers) {
+    return {
+        provide: `ENTRY_FILTER_PROVIDER_REGISTRAR_${label.toUpperCase()}`,
+        useFactory: (registry, ...resolved) => new EntryFilterBootstrapper(label, registry, resolved),
+        inject: [
+            { token: EntryFilterProviderRegistry, optional: true },
+            ...providers
+        ]
+    };
+}