vintasend-managed-templates 1.0.0-alpha2

package/dist/filters.js

@@ -0,0 +1,252 @@
+/**
+ * The filter vocabulary a template-manager backend evaluates.
+ *
+ * Spelled exactly the way `vintasend` spells its notification filters — camelCase fields,
+ * camelCase string lookups (`startsWith`, not `starts_with`), a `DateRange` with `from`/`to`,
+ * and the same `and`/`or`/`not` grouping — so a caller that already builds one kind of filter
+ * needs no second set of rules for this one.
+ */
+/**
+ * The fields `ManagedTemplateFilterFields` accepts, as data.
+ *
+ * Kept in step with the type by {@link ManagedTemplateFilterFieldName}, which fails to compile
+ * if the two drift apart — a field added to the type without a name here is a type error rather
+ * than a filter the service silently rejects.
+ */
+export const KNOWN_FILTER_FIELDS = [
+    'name',
+    'description',
+    'key',
+    'version',
+    'templateManagedBackend',
+    'status',
+    'createdAtRange',
+    'updatedAtRange',
+    'includesAllTags',
+    'includesAnyOfTags',
+    'isAbstract',
+    'mostRecentActiveVersion',
+];
+const _allFilterFieldsListed = true;
+void _allFilterFieldsListed;
+/** The filter fields whose value is a list of tag slugs rather than a lookup object. */
+export const TAG_FILTER_FIELDS = ['includesAllTags', 'includesAnyOfTags'];
+/** The filter fields whose value is a bare boolean. */
+export const FLAG_FILTER_FIELDS = ['mostRecentActiveVersion', 'isAbstract'];
+const LOGICAL_KEYS = ['and', 'or', 'not'];
+const STRING_LOOKUPS = ['exact', 'startsWith', 'endsWith', 'includes'];
+const NUMERIC_LOOKUPS = ['gt', 'gte', 'lt', 'lte'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** True when `filter` is a field filter rather than an `and`/`or`/`not` group. */
+export function isFieldFilter(filter) {
+    return !LOGICAL_KEYS.some((key) => key in filter);
+}
+/** True when a string-field filter is a `StringFilterLookup` and not a bare string. */
+export function isStringFilterLookup(value) {
+    return (isRecord(value) &&
+        typeof value.value === 'string' &&
+        typeof value.lookup === 'string' &&
+        STRING_LOOKUPS.includes(value.lookup) &&
+        (value.caseSensitive === undefined || typeof value.caseSensitive === 'boolean'));
+}
+export function isNumericFilterLookup(value) {
+    return (isRecord(value) &&
+        typeof value.value === 'number' &&
+        typeof value.lookup === 'string' &&
+        NUMERIC_LOOKUPS.includes(value.lookup));
+}
+export function isDateRange(value) {
+    return isRecord(value) && (value.from instanceof Date || value.to instanceof Date);
+}
+export function isStatusInLookup(value) {
+    return (isRecord(value) &&
+        value.lookup === 'in' &&
+        Array.isArray(value.value) &&
+        value.value.every((entry) => typeof entry === 'string'));
+}
+export function isStatusExactLookup(value) {
+    return isRecord(value) && value.lookup === 'exact' && typeof value.value === 'string';
+}
+/**
+ * True when a value is a list of tag slugs.
+ *
+ * A bare string is deliberately rejected: `{ includesAllTags: 'welcome' }` would otherwise be
+ * spread character by character by a backend that iterates it, and silently ask for the tags
+ * `w`, `e`, `l`. Pass a one-element array instead.
+ */
+export function isTagsFilter(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+/** Every orderable field, for validation and for building a capability report. */
+export const MANAGED_TEMPLATE_ORDER_BY_FIELDS = [
+    'key',
+    'name',
+    'version',
+    'status',
+    'createdAt',
+    'updatedAt',
+];
+/** The capability key reporting whether a backend can order by `field`. */
+export function orderByCapabilityKey(field) {
+    return `orderBy.${field}`;
+}
+export const DEFAULT_TEMPLATE_BACKEND_FILTER_CAPABILITIES = {
+    // Composition. A backend that can evaluate field filters but not assemble them into
+    // and/or/not groups declines these. `notNested` is the narrower question of whether `not` may
+    // wrap a *group* rather than a single field filter.
+    'logical.and': true,
+    'logical.or': true,
+    'logical.not': true,
+    'logical.notNested': true,
+    // One key per field of `ManagedTemplateFilterFields`.
+    'fields.name': true,
+    'fields.description': true,
+    'fields.key': true,
+    'fields.version': true,
+    'fields.templateManagedBackend': true,
+    'fields.status': true,
+    'fields.createdAtRange': true,
+    'fields.updatedAtRange': true,
+    // Tag membership. A backend that stores no tags — or stores them but cannot query across
+    // them — declines these, and a caller drops the filter rather than failing the request. They
+    // are separate keys because "every tag" and "at least one tag" are different queries: the
+    // first needs a per-template count over the tags asked for, the second only membership.
+    'fields.includesAllTags': true,
+    'fields.includesAnyOfTags': true,
+    // Its own key because it is a different question from the rest: a backend answers it by
+    // comparing a row against the other versions of its key, which a store that keeps no version
+    // history cannot do.
+    'fields.mostRecentActiveVersion': true,
+    // Bases versus templates to send, answered from the stored `isAbstract` flag the backend
+    // derives on every write. A backend that keeps no such flag declines this.
+    'fields.isAbstract': true,
+    'stringLookups.exact': true,
+    'stringLookups.startsWith': true,
+    'stringLookups.endsWith': true,
+    'stringLookups.includes': true,
+    // These two are independent capabilities, not a flag and its negation:
+    //
+    // * `caseSensitive: false` — everything is forced case-insensitive, which is what a store on
+    //   a case-insensitive collation (MySQL's `*_ci`) does. It cannot honour
+    //   `caseSensitive: true`, nor a bare string filter, which means the same thing.
+    // * `caseInsensitive: false` — only exact-case matching is available, e.g. a store with
+    //   `LIKE` but no `ILIKE`.
+    //
+    // Deriving either from the other inverts the answer for exactly the backends that had a
+    // constraint worth reporting. Read the key you actually mean.
+    'stringLookups.caseSensitive': true,
+    'stringLookups.caseInsensitive': true,
+    // Ordering is new vocabulary rather than behaviour backends already have, so every key
+    // defaults to false. A backend that predates the ordering argument ignores it, and a `true`
+    // default would have it claim an order it never applies.
+    'orderBy.key': false,
+    'orderBy.name': false,
+    'orderBy.version': false,
+    'orderBy.status': false,
+    'orderBy.createdAt': false,
+    'orderBy.updatedAt': false,
+};
+/**
+ * Drop the parts of a filter the backend has declared it cannot answer.
+ *
+ * This is the other half of the capability report: reporting a limitation is only useful if
+ * something acts on it. Every caller that builds a filter would otherwise have to walk the
+ * capability map itself and reach its own conclusions, and they would disagree.
+ *
+ * **Dropping widens.** A pruned filter matches everything the original did and possibly more, so
+ * a caller sees extra rows rather than missing ones — a listing that could not collapse to one
+ * row per key shows every version, which is visible in the result. That is the whole reason
+ * filters are negotiated by dropping while *ordering* is negotiated by refusing: an ignored order
+ * leaves no trace in the rows at all. Check the report before trusting a filter to have narrowed.
+ *
+ * Returns an empty filter — which constrains nothing — when everything has been dropped.
+ */
+export function pruneUnsupportedFilters(filter, capabilities) {
+    const can = (key) => supportsCapability(capabilities, key);
+    if (isFieldFilter(filter)) {
+        return pruneFields(filter, can);
+    }
+    if ('and' in filter) {
+        if (!can('logical.and')) {
+            return {};
+        }
+        const kept = filter.and
+            .map((inner) => pruneUnsupportedFilters(inner, capabilities))
+            .filter((inner) => !isEmptyFilter(inner));
+        if (kept.length === 0)
+            return {};
+        // A one-element `and` is the element: fewer groups for a backend to translate.
+        return kept.length === 1 ? kept[0] : { and: kept };
+    }
+    if ('or' in filter) {
+        // An `or` cannot be partially dropped. Removing one branch of a disjunction *narrows* the
+        // result — the opposite of what dropping is allowed to do — so the whole group goes, and
+        // with it the constraint.
+        if (!can('logical.or')) {
+            return {};
+        }
+        const kept = filter.or.map((inner) => pruneUnsupportedFilters(inner, capabilities));
+        // If any branch pruned down to "everything", the disjunction is satisfied by every row.
+        if (kept.some(isEmptyFilter))
+            return {};
+        return { or: kept };
+    }
+    if (!can('logical.not')) {
+        return {};
+    }
+    const inner = pruneUnsupportedFilters(filter.not, capabilities);
+    // Negating "everything" is "nothing", which is not a widening — drop it instead.
+    if (isEmptyFilter(inner))
+        return {};
+    if (!isFieldFilter(inner) && !can('logical.notNested'))
+        return {};
+    return { not: inner };
+}
+/** True for a filter that constrains nothing, whatever shape it arrived in. */
+export function isEmptyFilter(filter) {
+    if (isFieldFilter(filter)) {
+        return Object.values(filter).every((value) => value === undefined);
+    }
+    if ('and' in filter)
+        return filter.and.every(isEmptyFilter);
+    if ('or' in filter)
+        return filter.or.every(isEmptyFilter);
+    return isEmptyFilter(filter.not);
+}
+function pruneFields(fields, can) {
+    const kept = {};
+    for (const field of KNOWN_FILTER_FIELDS) {
+        const value = fields[field];
+        if (value === undefined)
+            continue;
+        if (!can(`fields.${field}`))
+            continue;
+        if (isStringFilterLookup(value) && !supportedStringLookup(value, can))
+            continue;
+        // A bare string means exact and case-sensitive.
+        if (typeof value === 'string' &&
+            !(can('stringLookups.exact') && can('stringLookups.caseSensitive'))) {
+            continue;
+        }
+        kept[field] = value;
+    }
+    return kept;
+}
+function supportedStringLookup(filter, can) {
+    if (!can(`stringLookups.${filter.lookup}`))
+        return false;
+    return filter.caseSensitive === false
+        ? can('stringLookups.caseInsensitive')
+        : can('stringLookups.caseSensitive');
+}
+/**
+ * Read one capability, defaulting to supported.
+ *
+ * A missing key means "supported": backends declare only what they *cannot* do, so a capability
+ * added in a later release does not force every backend to re-declare it.
+ */
+export function supportsCapability(capabilities, key) {
+    return capabilities[key] ?? true;
+}

package/dist/in-memory-template-manager-backend.d.ts

@@ -0,0 +1,85 @@
+/**
+ * A complete `BaseTemplateManagerBackend` that keeps everything in process memory.
+ *
+ * Two jobs. It is what a test suite — this package's, a renderer's, an API's — runs against
+ * without standing up a database. And it is the executable statement of what the seam means:
+ * every rule the interface documents in prose (a new version starts in `draft`, retagging edits
+ * in place, `mostRecentActiveVersion` is answered against the key rather than the row) is code
+ * here, so a backend author has something to compare behaviour against rather than only prose.
+ *
+ * Not for production: nothing is persisted, nothing is locked, and every filter is evaluated by
+ * scanning the whole store.
+ */
+import type { BaseTemplateManagerBackend } from './base-template-manager-backend.js';
+import type { ManagedTemplateStatus, ManagedTemplateTagStatus } from './constants.js';
+import { type ManagedTemplateFilter, type ManagedTemplateFilterCapabilities, type ManagedTemplateOrderBy } from './filters.js';
+import type { ManagedTemplate, ManagedTemplateCreateInput, ManagedTemplateStatusHistory, ManagedTemplateTag, ManagedTemplateUpdateInput } from './types.js';
+export type InMemoryTemplateManagerBackendOptions = {
+    /** Overridden in tests so timestamps are deterministic. */
+    now?: () => Date;
+};
+export declare class InMemoryTemplateManagerBackend implements BaseTemplateManagerBackend {
+    private templates;
+    private tags;
+    private history;
+    private nextId;
+    private readonly now;
+    constructor(options?: InMemoryTemplateManagerBackendOptions);
+    createTemplate(data: ManagedTemplateCreateInput): Promise<ManagedTemplate>;
+    getTemplate(templateKey: string, version?: number | null): Promise<ManagedTemplate>;
+    updateTemplate(templateKey: string, data: ManagedTemplateUpdateInput): Promise<ManagedTemplate>;
+    deleteTemplate(templateKey: string, version?: number | null): Promise<void>;
+    createTemplateStatusUpdate(params: {
+        templateKey: string;
+        version: number;
+        status: ManagedTemplateStatus;
+        changedBy?: string | null;
+    }): Promise<void>;
+    getTemplateStatusHistory(templateKey: string, version?: number | null): Promise<ManagedTemplateStatusHistory[]>;
+    getOrCreateTags(texts: string[], tenant?: string | null): Promise<ManagedTemplateTag[]>;
+    createTag(text: string, tenant?: string | null): Promise<ManagedTemplateTag>;
+    getTag(slug: string): Promise<ManagedTemplateTag>;
+    updateTag(slug: string, text: string): Promise<ManagedTemplateTag>;
+    setTagStatus(slug: string, status: ManagedTemplateTagStatus): Promise<ManagedTemplateTag>;
+    deleteTag(slug: string): Promise<void>;
+    getTags(status?: ManagedTemplateTagStatus[] | null, search?: string | null, tenant?: string | null): Promise<ManagedTemplateTag[]>;
+    getTemplateTags(templateKey: string, version?: number | null): Promise<ManagedTemplateTag[]>;
+    setTemplateTags(templateKey: string, tags: string[], version?: number | null): Promise<ManagedTemplate>;
+    getAllTemplates(): Promise<ManagedTemplate[]>;
+    getTemplatesByStatus(status: ManagedTemplateStatus[]): Promise<ManagedTemplate[]>;
+    getFilteredTemplates(filters: ManagedTemplateFilter): Promise<ManagedTemplate[]>;
+    /**
+     * Everything, including every order.
+     *
+     * This backend holds the whole store in memory, so it can sort a complete result set before
+     * paging it — which is what ordering requires. It therefore declares the `orderBy.*` keys
+     * explicitly: they default to false, and a backend that can genuinely do it has to say so.
+     */
+    getFilterCapabilities(): ManagedTemplateFilterCapabilities;
+    getPaginatedTemplates(page: number, pageSize: number, orderBy?: ManagedTemplateOrderBy): Promise<ManagedTemplate[]>;
+    getPaginatedFilteredTemplates(filters: ManagedTemplateFilter, page: number, pageSize: number, orderBy?: ManagedTemplateOrderBy): Promise<ManagedTemplate[]>;
+    private deriveIsAbstract;
+    private versionsOf;
+    private find;
+    private requireTag;
+    private cleanText;
+    private insertTag;
+    /**
+     * Resolve texts to tags, creating what is missing — one tag per distinct text, in order.
+     *
+     * An existing tag is returned as it stands: its text and status are left alone, so re-using an
+     * archived tag does not quietly bring it back.
+     */
+    private resolveTags;
+    /** Keep the copies embedded on template rows in step with the tag record itself. */
+    private syncTagOnTemplates;
+    /**
+     * Evaluate a filter over the whole store.
+     *
+     * The semantics live in `filter-evaluation`, shared with every backend that has to finish a
+     * filter its query language could not express — so this store and a FHIR one agree on what
+     * `includesAllTags: []` means without either of them re-deriving it.
+     */
+    private matches;
+}
+//# sourceMappingURL=in-memory-template-manager-backend.d.ts.map

package/dist/in-memory-template-manager-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-template-manager-backend.d.ts","sourceRoot":"","sources":["../src/in-memory-template-manager-backend.ts"],"names":[],"mappings":"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"}

package/dist/in-memory-template-manager-backend.js

@@ -0,0 +1,323 @@
+/**
+ * A complete `BaseTemplateManagerBackend` that keeps everything in process memory.
+ *
+ * Two jobs. It is what a test suite — this package's, a renderer's, an API's — runs against
+ * without standing up a database. And it is the executable statement of what the seam means:
+ * every rule the interface documents in prose (a new version starts in `draft`, retagging edits
+ * in place, `mostRecentActiveVersion` is answered against the key rather than the row) is code
+ * here, so a backend author has something to compare behaviour against rather than only prose.
+ *
+ * Not for production: nothing is persisted, nothing is locked, and every filter is evaluated by
+ * scanning the whole store.
+ */
+import { isAbstract } from './composition.js';
+import { ManagedTemplateInvalidTagError, ManagedTemplateNotFoundError, ManagedTemplateTagAlreadyExistsError, ManagedTemplateTagNotFoundError, } from './errors.js';
+import { matchesTemplateFilter, paginate, sortTemplates } from './filter-evaluation.js';
+import { MANAGED_TEMPLATE_ORDER_BY_FIELDS, orderByCapabilityKey, } from './filters.js';
+import { nextAvailableSlug, normalizeTagText, slugifyTag } from './tags.js';
+export class InMemoryTemplateManagerBackend {
+    constructor(options = {}) {
+        this.templates = [];
+        this.tags = [];
+        this.history = [];
+        this.nextId = 1;
+        this.now = options.now ?? (() => new Date());
+    }
+    // -------------------------------------------------------------------------------------------
+    // Templates
+    // -------------------------------------------------------------------------------------------
+    async createTemplate(data) {
+        const timestamp = this.now();
+        const template = {
+            id: this.nextId++,
+            key: data.key,
+            version: 1,
+            name: data.name,
+            description: data.description,
+            templateManagedBackend: data.templateManagedBackend,
+            bodyTemplate: data.bodyTemplate,
+            subjectTemplate: data.subjectTemplate,
+            preheaderTemplate: data.preheaderTemplate,
+            status: 'draft',
+            tenant: data.tenant,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            tags: await this.resolveTags(data.tags ?? [], data.tenant),
+            isAbstract: this.deriveIsAbstract(data),
+        };
+        this.templates.push(template);
+        return structuredCloneTemplate(template);
+    }
+    async getTemplate(templateKey, version = null) {
+        const template = this.find(templateKey, version);
+        if (template === undefined) {
+            throw new ManagedTemplateNotFoundError(describeMissing(templateKey, version));
+        }
+        return structuredCloneTemplate(template);
+    }
+    async updateTemplate(templateKey, data) {
+        const previous = this.find(templateKey, null);
+        if (previous === undefined) {
+            throw new ManagedTemplateNotFoundError(describeMissing(templateKey, null));
+        }
+        // Resolved before the insert so an unusable tag text fails the whole update rather than
+        // leaving a new version behind with the wrong labels.
+        const tags = data.tags === undefined || data.tags === null
+            ? previous.tags
+            : await this.resolveTags(data.tags, previous.tenant);
+        const timestamp = this.now();
+        const sources = {
+            bodyTemplate: data.bodyTemplate || previous.bodyTemplate,
+            subjectTemplate: data.subjectTemplate ?? previous.subjectTemplate,
+            preheaderTemplate: data.preheaderTemplate ?? previous.preheaderTemplate,
+        };
+        const template = {
+            id: this.nextId++,
+            key: previous.key,
+            version: previous.version + 1,
+            name: data.name || previous.name,
+            description: data.description ?? previous.description,
+            templateManagedBackend: previous.templateManagedBackend,
+            ...sources,
+            // A copy nobody has reviewed should not inherit "published".
+            status: 'draft',
+            tenant: previous.tenant,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            tags,
+            isAbstract: this.deriveIsAbstract(sources),
+        };
+        this.templates.push(template);
+        return structuredCloneTemplate(template);
+    }
+    async deleteTemplate(templateKey, version = null) {
+        const template = this.find(templateKey, version);
+        if (template === undefined) {
+            throw new ManagedTemplateNotFoundError(describeMissing(templateKey, version));
+        }
+        this.templates = this.templates.filter((candidate) => candidate !== template);
+    }
+    async createTemplateStatusUpdate(params) {
+        const template = this.find(params.templateKey, params.version);
+        if (template === undefined) {
+            throw new ManagedTemplateNotFoundError(describeMissing(params.templateKey, params.version));
+        }
+        template.status = params.status;
+        template.updatedAt = this.now();
+        this.history.push({
+            templateKey: params.templateKey,
+            version: params.version,
+            status: params.status,
+            createdAt: this.now(),
+            changedBy: params.changedBy ?? null,
+            tenant: template.tenant,
+        });
+    }
+    async getTemplateStatusHistory(templateKey, version = null) {
+        if (this.versionsOf(templateKey).length === 0) {
+            throw new ManagedTemplateNotFoundError(describeMissing(templateKey, null));
+        }
+        return this.history
+            .filter((record) => record.templateKey === templateKey && (version === null || record.version === version))
+            .map((record) => ({ ...record }));
+    }
+    // -------------------------------------------------------------------------------------------
+    // Tags
+    // -------------------------------------------------------------------------------------------
+    async getOrCreateTags(texts, tenant = null) {
+        return this.resolveTags(texts, tenant);
+    }
+    async createTag(text, tenant = null) {
+        const cleaned = this.cleanText(text);
+        const slug = slugifyTag(cleaned);
+        if (this.tags.some((tag) => tag.slug === slug)) {
+            throw new ManagedTemplateTagAlreadyExistsError(`A tag with slug '${slug}' already exists.`);
+        }
+        return { ...(await this.insertTag(cleaned, tenant)) };
+    }
+    async getTag(slug) {
+        return { ...this.requireTag(slug) };
+    }
+    async updateTag(slug, text) {
+        const tag = this.requireTag(slug);
+        const cleaned = this.cleanText(text);
+        const base = slugifyTag(cleaned);
+        tag.text = cleaned;
+        tag.slug = await nextAvailableSlug(base, (candidate) => this.tags.some((other) => other !== tag && other.slug === candidate));
+        tag.updatedAt = this.now();
+        this.syncTagOnTemplates(tag);
+        return { ...tag };
+    }
+    async setTagStatus(slug, status) {
+        const tag = this.requireTag(slug);
+        tag.status = status;
+        tag.updatedAt = this.now();
+        this.syncTagOnTemplates(tag);
+        return { ...tag };
+    }
+    async deleteTag(slug) {
+        const tag = this.requireTag(slug);
+        this.tags = this.tags.filter((candidate) => candidate !== tag);
+        for (const template of this.templates) {
+            template.tags = template.tags.filter((candidate) => candidate.id !== tag.id);
+        }
+    }
+    async getTags(status = null, search = null, tenant = null) {
+        const term = search === null ? null : search.toLowerCase();
+        return this.tags
+            .filter((tag) => status === null || status.includes(tag.status))
+            .filter((tag) => tenant === null || tag.tenant === tenant)
+            .filter((tag) => term === null ||
+            tag.text.toLowerCase().includes(term) ||
+            tag.slug.toLowerCase().includes(term))
+            .map((tag) => ({ ...tag }));
+    }
+    async getTemplateTags(templateKey, version = null) {
+        const template = this.find(templateKey, version);
+        if (template === undefined) {
+            throw new ManagedTemplateNotFoundError(describeMissing(templateKey, version));
+        }
+        return template.tags.map((tag) => ({ ...tag }));
+    }
+    async setTemplateTags(templateKey, tags, version = null) {
+        const template = this.find(templateKey, version);
+        if (template === undefined) {
+            throw new ManagedTemplateNotFoundError(describeMissing(templateKey, version));
+        }
+        template.tags = await this.resolveTags(tags, template.tenant);
+        template.updatedAt = this.now();
+        return structuredCloneTemplate(template);
+    }
+    // -------------------------------------------------------------------------------------------
+    // Queries
+    // -------------------------------------------------------------------------------------------
+    async getAllTemplates() {
+        return this.templates.map(structuredCloneTemplate);
+    }
+    async getTemplatesByStatus(status) {
+        return this.templates
+            .filter((template) => status.includes(template.status))
+            .map(structuredCloneTemplate);
+    }
+    async getFilteredTemplates(filters) {
+        return this.templates
+            .filter((template) => this.matches(template, filters))
+            .map(structuredCloneTemplate);
+    }
+    /**
+     * Everything, including every order.
+     *
+     * This backend holds the whole store in memory, so it can sort a complete result set before
+     * paging it — which is what ordering requires. It therefore declares the `orderBy.*` keys
+     * explicitly: they default to false, and a backend that can genuinely do it has to say so.
+     */
+    getFilterCapabilities() {
+        return Object.fromEntries(MANAGED_TEMPLATE_ORDER_BY_FIELDS.map((field) => [orderByCapabilityKey(field), true]));
+    }
+    async getPaginatedTemplates(page, pageSize, orderBy) {
+        return paginate(sortTemplates(await this.getAllTemplates(), orderBy), page, pageSize);
+    }
+    async getPaginatedFilteredTemplates(filters, page, pageSize, orderBy) {
+        // Sorted before paging, never after: the page has to be chosen from an ordered set.
+        return paginate(sortTemplates(await this.getFilteredTemplates(filters), orderBy), page, pageSize);
+    }
+    // -------------------------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------------------------
+    deriveIsAbstract(sources) {
+        try {
+            return isAbstract(sources);
+        }
+        catch {
+            // A source nobody can parse has no answer. Storing `false` keeps the syntax error out of
+            // the write, where the edit boundary has already had its chance to refuse it.
+            return false;
+        }
+    }
+    versionsOf(templateKey) {
+        return this.templates.filter((template) => template.key === templateKey);
+    }
+    find(templateKey, version) {
+        const versions = this.versionsOf(templateKey);
+        if (version !== null) {
+            return versions.find((template) => template.version === version);
+        }
+        return versions.reduce((latest, template) => latest === undefined || template.version > latest.version ? template : latest, undefined);
+    }
+    requireTag(slug) {
+        const normalized = slugifyTag(slug);
+        const tag = this.tags.find((candidate) => candidate.slug === normalized);
+        if (tag === undefined) {
+            throw new ManagedTemplateTagNotFoundError(`No tag with slug '${slug}' was found.`);
+        }
+        return tag;
+    }
+    cleanText(text) {
+        const cleaned = normalizeTagText(text);
+        if (!cleaned || !slugifyTag(cleaned)) {
+            throw new ManagedTemplateInvalidTagError(`Tag text ${JSON.stringify(text)} has no characters that can be turned into a slug.`);
+        }
+        return cleaned;
+    }
+    async insertTag(text, tenant) {
+        const timestamp = this.now();
+        const slug = await nextAvailableSlug(slugifyTag(text), (candidate) => this.tags.some((tag) => tag.slug === candidate));
+        const tag = {
+            id: this.nextId++,
+            text,
+            slug,
+            status: 'active',
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            tenant,
+        };
+        this.tags.push(tag);
+        return tag;
+    }
+    /**
+     * Resolve texts to tags, creating what is missing — one tag per distinct text, in order.
+     *
+     * An existing tag is returned as it stands: its text and status are left alone, so re-using an
+     * archived tag does not quietly bring it back.
+     */
+    async resolveTags(texts, tenant) {
+        const resolved = [];
+        for (const text of texts) {
+            const cleaned = this.cleanText(text);
+            const slug = slugifyTag(cleaned);
+            if (resolved.some((tag) => tag.slug === slug)) {
+                continue;
+            }
+            const existing = this.tags.find((tag) => tag.slug === slug);
+            resolved.push(existing ?? (await this.insertTag(cleaned, tenant)));
+        }
+        return resolved;
+    }
+    /** Keep the copies embedded on template rows in step with the tag record itself. */
+    syncTagOnTemplates(tag) {
+        for (const template of this.templates) {
+            template.tags = template.tags.map((candidate) => (candidate.id === tag.id ? tag : candidate));
+        }
+    }
+    /**
+     * Evaluate a filter over the whole store.
+     *
+     * The semantics live in `filter-evaluation`, shared with every backend that has to finish a
+     * filter its query language could not express — so this store and a FHIR one agree on what
+     * `includesAllTags: []` means without either of them re-deriving it.
+     */
+    matches(template, filters) {
+        return matchesTemplateFilter(template, filters, {
+            versionsOfKey: (key) => this.versionsOf(key),
+        });
+    }
+}
+function structuredCloneTemplate(template) {
+    return { ...template, tags: template.tags.map((tag) => ({ ...tag })) };
+}
+function describeMissing(templateKey, version) {
+    if (version === null) {
+        return `No template with key '${templateKey}' was found.`;
+    }
+    return `Template '${templateKey}' has no version ${version}.`;
+}