@cosmicdrift/kumiko-bundled-features 0.383.0 → 0.384.0

package/dist/sessions/web/user-agent.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod";
+export declare const USER_AGENT_BROWSERS: readonly ["Edge", "Opera", "Samsung Internet", "Firefox", "Chrome", "Safari"];
+export declare const USER_AGENT_OPERATING_SYSTEMS: readonly ["Windows", "iOS", "Android", "macOS", "ChromeOS", "Linux"];
+export type UserAgentBrowser = (typeof USER_AGENT_BROWSERS)[number];
+export type UserAgentOperatingSystem = (typeof USER_AGENT_OPERATING_SYSTEMS)[number];
+export declare const parsedDeviceSchema: z.ZodNullable<z.ZodObject<{
+    browser: z.ZodNullable<z.ZodEnum<{
+        Chrome: "Chrome";
+        Edge: "Edge";
+        Firefox: "Firefox";
+        Opera: "Opera";
+        Safari: "Safari";
+        "Samsung Internet": "Samsung Internet";
+    }>>;
+    browserMajor: z.ZodNullable<z.ZodNumber>;
+    os: z.ZodNullable<z.ZodEnum<{
+        Android: "Android";
+        ChromeOS: "ChromeOS";
+        Linux: "Linux";
+        Windows: "Windows";
+        iOS: "iOS";
+        macOS: "macOS";
+    }>>;
+}, z.core.$strip>>;
+export type ParsedDevice = z.infer<typeof parsedDeviceSchema>;
+export declare function parseUserAgent(userAgent: string | null): ParsedDevice;

package/dist/sessions/web/user-agent.js

@@ -0,0 +1,58 @@
+import * as z from "zod";
+export const USER_AGENT_BROWSERS = [
+    "Edge",
+    "Opera",
+    "Samsung Internet",
+    "Firefox",
+    "Chrome",
+    "Safari",
+];
+export const USER_AGENT_OPERATING_SYSTEMS = [
+    "Windows",
+    "iOS",
+    "Android",
+    "macOS",
+    "ChromeOS",
+    "Linux",
+];
+export const parsedDeviceSchema = z
+    .object({
+    browser: z.enum(USER_AGENT_BROWSERS).nullable(),
+    browserMajor: z.number().int().nullable(),
+    os: z.enum(USER_AGENT_OPERATING_SYSTEMS).nullable(),
+})
+    .nullable();
+// Order matters: Chromium forks and iOS Chrome/Firefox also carry the engine tokens of the browsers they derive from.
+const BROWSER_PATTERNS = [
+    { browser: "Edge", pattern: /\bEdg(?:e|A|iOS)?\/(\d+)/ },
+    { browser: "Opera", pattern: /\bOPR\/(\d+)/ },
+    { browser: "Samsung Internet", pattern: /\bSamsungBrowser\/(\d+)/ },
+    { browser: "Firefox", pattern: /\b(?:Firefox|FxiOS)\/(\d+)/ },
+    { browser: "Chrome", pattern: /\b(?:Chrome|CriOS)\/(\d+)/ },
+    { browser: "Safari", pattern: /\bVersion\/(\d+)[\s\S]*\bSafari\// },
+];
+// iPhone/iPad UAs say "like Mac OS X" and Android UAs say "Linux", so the more specific systems come first.
+const OPERATING_SYSTEM_PATTERNS = [
+    { os: "Windows", pattern: /\bWindows\b/ },
+    { os: "iOS", pattern: /\b(?:iPhone|iPad|iPod)\b/ },
+    { os: "Android", pattern: /\bAndroid\b/ },
+    { os: "macOS", pattern: /\bMacintosh\b/ },
+    { os: "ChromeOS", pattern: /\bCrOS\b/ },
+    { os: "Linux", pattern: /\bLinux\b/ },
+];
+export function parseUserAgent(userAgent) {
+    if (userAgent === null || userAgent === "")
+        return null;
+    let browser = null;
+    let browserMajor = null;
+    for (const candidate of BROWSER_PATTERNS) {
+        const match = candidate.pattern.exec(userAgent);
+        if (match) {
+            browser = candidate.browser;
+            browserMajor = match[1] === undefined ? null : Number(match[1]);
+            break;
+        }
+    }
+    const os = OPERATING_SYSTEM_PATTERNS.find((candidate) => candidate.pattern.test(userAgent))?.os ?? null;
+    return browser === null && os === null ? null : { browser, browserMajor, os };
+}

package/dist/tags/entity.d.ts

@@ -1,214 +1,34 @@
 import { type EntityDefinition } from "@cosmicdrift/kumiko-framework/engine";
 export declare const tagEntity: EntityDefinition<{
-    readonly name: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly name: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly color: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly color: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: false;
     };
-    readonly scope: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly scope: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: false;
     };
 }, "tenant">;
 export declare function createTagAssignmentEntity(access?: EntityDefinition["access"], parents?: readonly string[]): EntityDefinition<{
-    readonly tagId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly tagId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly entityType: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly entityType: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly entityId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly entityId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
 }, "tenant">;
 export declare const tagAssignmentEntity: EntityDefinition<{
-    readonly tagId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly tagId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly entityType: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly entityType: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly entityId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly entityId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
 }, "tenant">;

package/dist/template-resolver/feature.d.ts

@@ -51,6 +51,7 @@ export declare function createTemplateResolverFeature(opts?: TemplateResolverOpt
             overview: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             layoutSource: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             tenantOverrides: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            tenantOverrideCounts: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             diffToSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             validate: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             preview: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;

package/dist/template-resolver/feature.js

@@ -24,6 +24,7 @@ import { makeResourceUploadWrite } from "./handlers/resource-upload.write.js";
 import { makeSendTestWrite } from "./handlers/send-test.write.js";
 import { sendTestStatusQuery } from "./handlers/send-test-status.query.js";
 import { makeSetWrite } from "./handlers/set.write.js";
+import { tenantOverrideCountsQuery } from "./handlers/tenant-override-counts.query.js";
 import { tenantOverridesQuery } from "./handlers/tenant-overrides.query.js";
 import { makeArchiveSystemWrite, makeArchiveWrite, makePublishSystemWrite, makePublishWrite, } from "./handlers/toggle-status.write.js";
 import { upsertSystemWrite } from "./handlers/upsert-system.write.js";
@@ -130,6 +131,7 @@ export function createTemplateResolverFeature(opts = {}) {
             overview: r.queryHandler(makeOverviewQuery(policy)),
             layoutSource: r.queryHandler(layoutSourceQuery),
             tenantOverrides: r.queryHandler(tenantOverridesQuery),
+            tenantOverrideCounts: r.queryHandler(tenantOverrideCountsQuery),
             diffToSystem: r.queryHandler(diffToSystemQuery),
             validate: r.queryHandler(validateQuery),
             preview: r.queryHandler(previewQuery),

package/dist/template-resolver/handlers/overview.query.d.ts

@@ -38,6 +38,11 @@ export type OverviewRow = {
     readonly modifiedAt: string;
     readonly usedBy: readonly OverviewUsage[];
     readonly usedByCount: number;
+    /** SystemAdmin only, system-origin rows: tenants overriding this template; total is null without the tenant feature. */
+    readonly overriddenBy?: {
+        readonly active: number;
+        readonly total: number | null;
+    };
 };
 export type OverviewResponse = {
     readonly rows: readonly OverviewRow[];

package/dist/template-resolver/handlers/overview.query.js

@@ -3,12 +3,14 @@ import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { templateResourcesTable } from "../table.js";
 import { deliveryPolicyOf, isTenantOverrideServed, } from "../template-delivery-policy.js";
-import { activeSinceOf, activeVersionOf, draftViewerTenantId, isHiddenSystemDraft, parseTemplateDraft, servedVersionOf, } from "../template-draft.js";
+import { activeSinceOf, activeVersionOf, draftViewerTenantId, isHiddenSystemDraft, isSystemAdmin, parseTemplateDraft, servedVersionOf, } from "../template-draft.js";
 import { mayEditTemplate } from "../template-edit-policy.js";
 import { isSystemOnlyTemplateHiddenFrom } from "../template-system-only.js";
 import { collectTemplateUsage } from "../template-usage.js";
 import { DEFAULT_MAIL_LAYOUT_SLUG, FALLBACK_LOCALE, } from "../web/constants.js";
+import { TemplateResolverQueries } from "../web/qualified-names.js";
 import { storedRecord } from "./template-gates.js";
+import { tenantOverrideCountsResultSchema } from "./tenant-override-counts.query.js";
 const OVERVIEW_KINDS = ["mail", "document-pdf", "mail-layout", "pdf-layout"];
 const OVERVIEW_ROW_LIMIT = 5000;
 const LOCKED_OVERRIDE_I18N_KEY = "templateResolver.overview.lockedOverride";
@@ -188,6 +190,18 @@ function withUsage(draft, layoutSlugByDocument, registry, effectiveLayouts) {
     }
     return { ...draft, usedBy, usedByCount: usedBy.length };
 }
+function withOverriddenBy(rows, overrides) {
+    const activeByKey = new Map(overrides.counts.map((entry) => [`${entry.kind}|${entry.slug}`, entry.activeOverrides]));
+    return rows.map((row) => row.origin === "system"
+        ? {
+            ...row,
+            overriddenBy: {
+                active: activeByKey.get(`${row.kind}|${row.slug}`) ?? 0,
+                total: overrides.totalTenants,
+            },
+        }
+        : row);
+}
 function filterRows(rows, search, filters, layoutSlug) {
     const needle = search?.trim().toLowerCase() ?? "";
     return rows.filter((row) => {
@@ -234,7 +248,10 @@ export function makeOverviewQuery(policy) {
             const deliveryPolicy = deliveryPolicyOf(ctx.registry);
             const { drafts, layoutSlugByDocument } = buildDrafts(groupBySlugAndKind(visibleRows), query.user, deliveryPolicy);
             const effectiveLayouts = effectiveMailLayoutSlugs(visibleRows, deliveryPolicy);
-            const overviewRows = drafts.map((draft) => withUsage(draft, layoutSlugByDocument, ctx.registry, effectiveLayouts));
+            const rowsWithUsage = drafts.map((draft) => withUsage(draft, layoutSlugByDocument, ctx.registry, effectiveLayouts));
+            const overviewRows = isSystemAdmin(query.user)
+                ? withOverriddenBy(rowsWithUsage, tenantOverrideCountsResultSchema.parse(await ctx.query(TemplateResolverQueries.tenantOverrideCounts, {})))
+                : rowsWithUsage;
             const filtered = filterRows(overviewRows, payload.search, payload.filters ?? [], payload.layoutSlug);
             const sortField = payload.sort !== undefined && isSortField(payload.sort) ? payload.sort : "modifiedAt";
             const direction = (payload.sortDirection ?? "desc") === "desc" ? -1 : 1;

package/dist/template-resolver/handlers/tenant-override-counts.query.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod";
+export declare const tenantOverrideCountsResultSchema: z.ZodObject<{
+    totalTenants: z.ZodNullable<z.ZodNumber>;
+    counts: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        kind: z.ZodString;
+        activeOverrides: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const tenantOverrideCountsQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"tenant-override-counts", z.ZodObject<{}, z.core.$strip>, {
+    totalTenants: number | null;
+    counts: {
+        slug: string;
+        kind: string;
+        activeOverrides: number;
+    }[];
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/tenant-override-counts.query.js

@@ -0,0 +1,35 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/db";
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { templateResourcesTable } from "../table.js";
+import { loadEnabledTenantIds, pickBestRowPerTenant, TENANT_OVERRIDES_REASON, } from "./tenant-override-selection.js";
+export const tenantOverrideCountsResultSchema = z.object({
+    totalTenants: z.number().nullable(),
+    counts: z.array(z.object({ slug: z.string(), kind: z.string(), activeOverrides: z.number() })),
+});
+export const tenantOverrideCountsQuery = defineQueryHandler({
+    name: "tenant-override-counts",
+    schema: z.object({}),
+    access: { roles: ["SystemAdmin"] },
+    description: "Counts, per template slug and kind, the enabled tenants that override it with an active version, next to the number of enabled tenants; one query for the whole template overview instead of one tenant-overrides call per row.",
+    escapeHatch: { grants: ["unsafeRaw"], reason: TENANT_OVERRIDES_REASON },
+    handler: async (_query, ctx) => {
+        const found = await selectMany(ctx.db.unsafeRaw(), templateResourcesTable, {
+            scope: "tenant",
+        });
+        const enabledTenantIds = await loadEnabledTenantIds(ctx);
+        const rowsBySlugAndKind = new Map();
+        for (const row of found) {
+            const key = `${row.kind}|${row.slug}`;
+            const group = rowsBySlugAndKind.get(key) ?? { slug: row.slug, kind: row.kind, rows: [] };
+            group.rows.push(row);
+            rowsBySlugAndKind.set(key, group);
+        }
+        const counts = [...rowsBySlugAndKind.values()].map(({ slug, kind, rows }) => ({
+            slug,
+            kind,
+            activeOverrides: [...pickBestRowPerTenant(rows, enabledTenantIds).values()].filter((row) => row.status === "active").length,
+        }));
+        return { totalTenants: enabledTenantIds === null ? null : enabledTenantIds.size, counts };
+    },
+});

package/dist/template-resolver/handlers/tenant-override-selection.d.ts

@@ -0,0 +1,12 @@
+import type { TemplateResourceRow } from "../table.ts";
+export declare const TENANT_OVERRIDES_REASON = "SystemAdmin template overview lists which tenants override one system template; it reads tenant-scope template rows of every tenant (and the system row for the optional per-tenant diff), which the tenant-scoped db cannot reach";
+type TenantIdQueryContext = {
+    readonly registry: {
+        getQueryHandler(name: string): unknown;
+    };
+    readonly query: (name: string, payload: Record<string, never>) => Promise<unknown>;
+};
+/** Null when the tenant feature is not installed: every tenant row then counts. */
+export declare function loadEnabledTenantIds(ctx: TenantIdQueryContext): Promise<ReadonlySet<string> | null>;
+export declare function pickBestRowPerTenant(found: readonly TemplateResourceRow[], enabledTenantIds: ReadonlySet<string> | null): Map<string, TemplateResourceRow>;
+export {};

package/dist/template-resolver/handlers/tenant-override-selection.js

@@ -0,0 +1,34 @@
+import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { TenantQueries } from "../../tenant/index.js";
+export const TENANT_OVERRIDES_REASON = "SystemAdmin template overview lists which tenants override one system template; it reads tenant-scope template rows of every tenant (and the system row for the optional per-tenant diff), which the tenant-scoped db cannot reach";
+const tenantIdsSchema = z.array(z.string());
+/** Null when the tenant feature is not installed: every tenant row then counts. */
+export async function loadEnabledTenantIds(ctx) {
+    if (ctx.registry.getQueryHandler(TenantQueries.activeTenantIds) === undefined)
+        return null;
+    return new Set(tenantIdsSchema.parse(await ctx.query(TenantQueries.activeTenantIds, {})));
+}
+// One row per tenant: its active override wins over a draft, then the newest version.
+function isBetterRow(candidate, current) {
+    if ((candidate.status === "active") !== (current.status === "active")) {
+        return candidate.status === "active";
+    }
+    return candidate.version > current.version;
+}
+function isCountedTenantRow(row, enabledTenantIds) {
+    if (row.tenantId === SYSTEM_TENANT_ID || row.status === "archived")
+        return false;
+    return enabledTenantIds === null || enabledTenantIds.has(row.tenantId);
+}
+export function pickBestRowPerTenant(found, enabledTenantIds) {
+    const bestByTenant = new Map();
+    for (const row of found) {
+        if (!isCountedTenantRow(row, enabledTenantIds))
+            continue;
+        const current = bestByTenant.get(row.tenantId);
+        if (current === undefined || isBetterRow(row, current))
+            bestByTenant.set(row.tenantId, row);
+    }
+    return bestByTenant;
+}

package/dist/template-resolver/handlers/tenant-overrides.query.js

@@ -6,40 +6,16 @@ import { templateResourcesTable } from "../table.js";
 import { servedVersionOf } from "../template-draft.js";
 import { buildOverrideDiff } from "./override-diff.js";
 import { kindSchema, localeSchema, templateSlugSchema } from "./shared.js";
-const TENANT_OVERRIDES_REASON = "SystemAdmin template overview lists which tenants override one system template; it reads tenant-scope template rows of every tenant (and the system row for the optional per-tenant diff), which the tenant-scoped db cannot reach";
-const tenantIdsSchema = z.array(z.string());
+import { loadEnabledTenantIds, pickBestRowPerTenant, TENANT_OVERRIDES_REASON, } from "./tenant-override-selection.js";
 const directorySchema = z.object({
     rows: z.array(z.object({ id: z.string(), label: z.string() })),
 });
 function labelsOf(raw) {
     return new Map(directorySchema.parse(raw).rows.map((row) => [row.id, row.label]));
 }
-// One row per tenant: its active override wins over a draft, then the newest version.
-function isBetterRow(candidate, current) {
-    if ((candidate.status === "active") !== (current.status === "active")) {
-        return candidate.status === "active";
-    }
-    return candidate.version > current.version;
-}
 function statusOf(row) {
     return row.status === "active" ? "active" : "draft";
 }
-function isCountedTenantRow(row, enabledTenantIds) {
-    if (row.tenantId === SYSTEM_TENANT_ID || row.status === "archived")
-        return false;
-    return enabledTenantIds === null || enabledTenantIds.has(row.tenantId);
-}
-function pickBestRowPerTenant(found, enabledTenantIds) {
-    const bestByTenant = new Map();
-    for (const row of found) {
-        if (!isCountedTenantRow(row, enabledTenantIds))
-            continue;
-        const current = bestByTenant.get(row.tenantId);
-        if (current === undefined || isBetterRow(row, current))
-            bestByTenant.set(row.tenantId, row);
-    }
-    return bestByTenant;
-}
 function toOverrideRow(row, tenantLabels, userLabels) {
     const changedById = row.modifiedById ?? row.insertedById;
     return {
@@ -74,10 +50,8 @@ export const tenantOverridesQuery = defineQueryHandler({
             scope: "tenant",
             ...(locale === undefined ? {} : { locale }),
         });
-        const hasTenantFeature = ctx.registry.getQueryHandler(TenantQueries.activeTenantIds) !== undefined;
-        const enabledTenantIds = hasTenantFeature
-            ? new Set(tenantIdsSchema.parse(await ctx.query(TenantQueries.activeTenantIds, {})))
-            : null;
+        const enabledTenantIds = await loadEnabledTenantIds(ctx);
+        const hasTenantFeature = enabledTenantIds !== null;
         const bestByTenant = pickBestRowPerTenant(found, enabledTenantIds);
         const best = [...bestByTenant.values()];
         const tenantLabels = hasTenantFeature