@orthacms/i18n-server 0.0.0-reserve.0

package/dist/lib/insights/infrastructure/queries/localization-coverage.query.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizationCoverageQuery = 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 content_server_1 = require("@orthacms/content-server");
+const locale_registry_service_1 = require("../../../locales/services/locale-registry.service");
+/** Reads a generated table's columns by property name. */
+function columnsOf(type) {
+    return type.table;
+}
+/**
+ * Live read-model for the localization coverage widget.
+ *
+ * **This lives in i18n-server, not content-server, and that is not arbitrary.**
+ * Coverage is a question about a set the content plugin deliberately does not
+ * know: the *configured* locales. content-server owns the `locale` column's
+ * shape and nothing about what a locale means, so it can report which slugs
+ * happen to appear in the data but not which ones are missing — and "missing"
+ * is the entire widget. `LocaleRegistryService` is the source of that set, and
+ * it is here.
+ *
+ * Like content's own insights query this aggregates **on demand**, per type,
+ * with no projection: a localized collection is its own generated
+ * `content_<name>` table, so a workspace-wide answer is inherently a fan-out.
+ */
+let LocalizationCoverageQuery = class LocalizationCoverageQuery {
+    db;
+    registry;
+    locales;
+    constructor(db, registry, locales) {
+        this.db = db;
+        this.registry = registry;
+        this.locales = locales;
+    }
+    /** Coverage across every localized content type in the workspace. */
+    async coverage(workspaceId) {
+        const configured = this.locales.all();
+        const slugs = configured.map((locale) => locale.slug);
+        const localizedTypes = this.registry.all().filter((type) => type.i18n);
+        /** Records holding a row in each locale, by slug. */
+        const translated = new Map(slugs.map((slug) => [slug, 0]));
+        const types = [];
+        let records = 0;
+        let localized = 0;
+        let single = 0;
+        for (const type of localizedTypes) {
+            for (const row of await this.perLocale(type, workspaceId, slugs)) {
+                translated.set(row.locale, (translated.get(row.locale) ?? 0) + row.translated);
+            }
+            const spread = await this.groupSpread(type, workspaceId, slugs, configured.length);
+            records += spread.records;
+            localized += spread.complete;
+            single += spread.single;
+            // A type the workspace has never used is noise on a chart about
+            // where the outstanding work sits — and listing it would push the
+            // types that do hold work further down.
+            if (spread.records === 0)
+                continue;
+            types.push({
+                name: type.name,
+                label: type.label,
+                records: spread.records,
+                localized: spread.complete,
+                notLocalized: configured.length > 1 ? spread.single : 0,
+                requiresLocalization: spread.records - spread.complete
+            });
+        }
+        types.sort((a, b) => b.records - a.records);
+        const locales = configured.map((locale) => {
+            const covered = translated.get(locale.slug) ?? 0;
+            return {
+                locale: locale.slug,
+                name: locale.name,
+                isDefault: locale.isDefault ?? false,
+                translated: covered,
+                missing: records - covered
+            };
+        });
+        return {
+            locales,
+            records,
+            localized,
+            // With one locale configured there is nowhere to translate to, so
+            // every record trivially covers "all" of them — reporting those
+            // same records as "not localized" would state both at once.
+            notLocalized: configured.length > 1 ? single : 0,
+            requiresLocalization: records - localized,
+            types
+        };
+    }
+    /**
+     * Records holding a row in each locale, for one type.
+     *
+     * `count(distinct locale_group_id)` rather than `count(*)`: the
+     * `(locale_group_id, locale)` unique index makes those equal in a healthy
+     * table, and the distinct keeps the figure honest against a paranoid type
+     * where the index is partial and a trashed row could otherwise be counted
+     * twice.
+     */
+    async perLocale(type, workspaceId, slugs) {
+        const columns = columnsOf(type);
+        // The generated tables are reached as an untyped column bag, so both
+        // the projection and the grouping go through `sql` fragments — a bare
+        // `AnyColumn` carries no dialect and doesn't satisfy the builder's
+        // overloads.
+        const locale = (0, drizzle_orm_1.sql) `${columns['locale']}`;
+        return this.db
+            .select({
+            locale,
+            translated: (0, drizzle_orm_1.sql) `cast(count(distinct ${columns['localeGroupId']}) as int)`
+        })
+            .from(type.table)
+            .where(this.configuredScope(type, workspaceId, slugs))
+            .groupBy(locale);
+    }
+    /**
+     * How many translation groups this type has, how many are complete, and how
+     * many sit in a single language.
+     *
+     * One grouped subquery folded by an outer aggregate — the alternative,
+     * reading one row per group and counting in JS, would pull the workspace's
+     * whole content set over the wire to produce three integers.
+     */
+    async groupSpread(type, workspaceId, slugs, configuredCount) {
+        const columns = columnsOf(type);
+        const groups = this.db
+            .select({
+            covered: (0, drizzle_orm_1.sql) `count(distinct ${columns['locale']})`.as('covered')
+        })
+            .from(type.table)
+            .where(this.configuredScope(type, workspaceId, slugs))
+            .groupBy((0, drizzle_orm_1.sql) `${columns['localeGroupId']}`)
+            .as('groups');
+        // The subquery alias carries no column type through, so both filters
+        // are raw fragments rather than `eq(...)`, whose overloads can't
+        // resolve one.
+        const [row] = await this.db
+            .select({
+            records: (0, drizzle_orm_1.sql) `cast(count(*) as int)`,
+            complete: (0, drizzle_orm_1.sql) `cast(count(*) filter (
+                    where ${groups.covered} = ${configuredCount}
+                ) as int)`,
+            single: (0, drizzle_orm_1.sql) `cast(count(*) filter (
+                    where ${groups.covered} = 1
+                ) as int)`
+        })
+            .from(groups);
+        return {
+            records: row?.records ?? 0,
+            complete: row?.complete ?? 0,
+            single: row?.single ?? 0
+        };
+    }
+    /**
+     * Workspace scope, the soft-delete guard, **and** the configured locale set.
+     *
+     * The locale filter is what makes "complete" mean what it says. A row in a
+     * slug the host has since removed from its config is not coverage of
+     * anything, and left in it would push a group's distinct-locale count past
+     * the configured total — so a record could be over-covered and still not
+     * counted as complete. Filtering here also drops a group made entirely of
+     * such rows, which is the right answer rather than a record with zero
+     * languages.
+     */
+    configuredScope(type, workspaceId, slugs) {
+        const columns = columnsOf(type);
+        return (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(columns['workspaceId'], workspaceId), (0, drizzle_orm_1.inArray)(columns['locale'], slugs), type.paranoid ? (0, drizzle_orm_1.isNull)(columns['deletedAt']) : undefined);
+    }
+};
+exports.LocalizationCoverageQuery = LocalizationCoverageQuery;
+exports.LocalizationCoverageQuery = LocalizationCoverageQuery = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__param(1, (0, content_server_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Object, Function, locale_registry_service_1.LocaleRegistryService])
+], LocalizationCoverageQuery);

package/dist/lib/insights/types/i18n-insights-view.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Read-side view shapes for the localization Insights widget.
+ *
+ * A **transport contract**, restated verbatim by `i18n-admin` (the admin can't
+ * import a server package across the module boundary). Derived live from the
+ * localized collection tables — this plugin owns no table and keeps no
+ * projection.
+ */
+/** How much of the workspace's localized content exists in one locale. */
+export interface LocaleCoverageView {
+    /** The configured locale slug. */
+    locale: string;
+    /** Its display name, from the host's config. */
+    name: string;
+    /** Whether it is the configured default locale. */
+    isDefault: boolean;
+    /** Records that have a row in this locale. */
+    translated: number;
+    /** Records that do not. */
+    missing: number;
+}
+/**
+ * One localized content type's own coverage.
+ *
+ * The same four figures as the workspace envelope, scoped to a type — which is
+ * what turns "122 records need translating" into "and 88 of them are articles".
+ * A workspace-wide total says work exists; only the per-type split says where.
+ */
+export interface ContentTypeCoverageView {
+    /** The type's machine name. */
+    name: string;
+    /** Its human label. */
+    label: string;
+    /** Translation groups of this type. */
+    records: number;
+    /** Of those, the ones present in every configured locale. */
+    localized: number;
+    /** Of those, the ones present in exactly one locale. */
+    notLocalized: number;
+    /** Of those, the ones missing at least one locale. */
+    requiresLocalization: number;
+}
+/**
+ * Localization coverage across every `i18n: true` content type.
+ *
+ * The unit is a **record**, not a row: a localized entry is one row per
+ * language sharing a `locale_group_id`, so counting rows would report a
+ * workspace of 40 stories in 3 languages as 120 things and make every
+ * percentage meaningless. Every figure below counts translation groups.
+ *
+ * `notLocalized` is a **subset** of `requiresLocalization`, not a second slice
+ * of it — a record in one language of four both "has no translations" and
+ * "needs some". They are separate because they are separate jobs: one is
+ * starting a translation, the other is finishing it.
+ */
+export interface I18nCoverageView {
+    /** One entry per configured locale, in config order. */
+    locales: LocaleCoverageView[];
+    /** Translation groups across every localized type. */
+    records: number;
+    /** Records that exist in **every** configured locale. */
+    localized: number;
+    /**
+     * Records that exist in exactly one locale — nothing translated yet.
+     *
+     * Always `0` when the deployment configures a single locale: there is
+     * nowhere to translate to, so every record would otherwise be reported as
+     * both fully localized and not localized at all.
+     */
+    notLocalized: number;
+    /** Records missing at least one configured locale (`records - localized`). */
+    requiresLocalization: number;
+    /**
+     * Per-type coverage, most records first.
+     *
+     * A type the workspace has never used is **omitted** rather than listed at
+     * zero — the same rule the content pipeline applies. A permanently empty row
+     * is noise on a chart about where the outstanding work sits, and it would
+     * push the types that do hold work further down the list.
+     */
+    types: ContentTypeCoverageView[];
+}
+//# sourceMappingURL=i18n-insights-view.d.ts.map

package/dist/lib/insights/types/i18n-insights-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n-insights-view.d.ts","sourceRoot":"","sources":["../../../../src/lib/insights/types/i18n-insights-view.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,kBAAkB;IAC/B,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACpC,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,oBAAoB,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC7B,wDAAwD;IACxD,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;;;;OAOG;IACH,KAAK,EAAE,uBAAuB,EAAE,CAAC;CACpC"}

package/dist/lib/insights/types/i18n-insights-view.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Read-side view shapes for the localization Insights widget.
+ *
+ * A **transport contract**, restated verbatim by `i18n-admin` (the admin can't
+ * import a server package across the module boundary). Derived live from the
+ * localized collection tables — this plugin owns no table and keeps no
+ * projection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/locales/controllers/list-locales.controller.d.ts

@@ -0,0 +1,26 @@
+import type { LocaleDef } from '../../types/locale';
+import { LocaleRegistryService } from '../services/locale-registry.service';
+/** The `GET /api/i18n/locales` response envelope. */
+export interface LocalesView {
+    /** Configured locales in display order; exactly one `isDefault`. */
+    items: LocaleDef[];
+}
+/**
+ * `GET /api/i18n/locales` — the configured locales, in display order. The
+ * admin's single source for the locale switcher / widget; any authenticated
+ * session may read it (the global `AuthGuard` applies; locales carry no
+ * per-workspace data).
+ *
+ * Each item carries everything a consumer needs to render the language
+ * *correctly*, not just to name it: `slug` doubles as the HTML `lang` value
+ * (it is a BCP-47 tag by contract) and `dir` is the resolved text direction.
+ * Together they are what lets the entry editor, the preview, and a published
+ * page mark up a translation as the language it is — which is the whole of
+ * WCAG 3.1.2 and, for an RTL locale, of 1.3.2.
+ */
+export declare class ListLocalesController {
+    private readonly locales;
+    constructor(locales: LocaleRegistryService);
+    list(): LocalesView;
+}
+//# sourceMappingURL=list-locales.controller.d.ts.map

package/dist/lib/locales/controllers/list-locales.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-locales.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/locales/controllers/list-locales.controller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAE5E,qDAAqD;AACrD,MAAM,WAAW,WAAW;IACxB,oEAAoE;IACpE,KAAK,EAAE,SAAS,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,qBACa,qBAAqB;IAClB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,qBAAqB;IAG3D,IAAI,IAAI,WAAW;CAYtB"}

package/dist/lib/locales/controllers/list-locales.controller.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListLocalesController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const locale_registry_service_1 = require("../services/locale-registry.service");
+/**
+ * `GET /api/i18n/locales` — the configured locales, in display order. The
+ * admin's single source for the locale switcher / widget; any authenticated
+ * session may read it (the global `AuthGuard` applies; locales carry no
+ * per-workspace data).
+ *
+ * Each item carries everything a consumer needs to render the language
+ * *correctly*, not just to name it: `slug` doubles as the HTML `lang` value
+ * (it is a BCP-47 tag by contract) and `dir` is the resolved text direction.
+ * Together they are what lets the entry editor, the preview, and a published
+ * page mark up a translation as the language it is — which is the whole of
+ * WCAG 3.1.2 and, for an RTL locale, of 1.3.2.
+ */
+let ListLocalesController = class ListLocalesController {
+    locales;
+    constructor(locales) {
+        this.locales = locales;
+    }
+    list() {
+        return {
+            items: this.locales.all().map(({ slug, name, isDefault, dir }) => ({
+                slug,
+                name,
+                isDefault: isDefault ?? false,
+                // The registry always resolves a direction; the fallback is
+                // for type flow only.
+                dir: dir ?? 'ltr'
+            }))
+        };
+    }
+};
+exports.ListLocalesController = ListLocalesController;
+tslib_1.__decorate([
+    (0, common_1.Get)('locales'),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", Object)
+], ListLocalesController.prototype, "list", null);
+exports.ListLocalesController = ListLocalesController = tslib_1.__decorate([
+    (0, common_1.Controller)('i18n'),
+    tslib_1.__metadata("design:paramtypes", [locale_registry_service_1.LocaleRegistryService])
+], ListLocalesController);

package/dist/lib/locales/services/locale-registry.service.d.ts

@@ -0,0 +1,26 @@
+import type { I18nPluginConfig, LocaleDef } from '../../types/locale';
+/**
+ * Read access to the validated locale configuration — the runtime authority
+ * every other i18n service consults. It wraps the domain {@link LocaleSet} /
+ * {@link LocalePolicy} (rebuilt from the already-validated config), so every
+ * service resolves locales through the same domain rule; it exposes the plain
+ * {@link LocaleDef} shape its callers expect and maps the domain's
+ * {@link UnknownLocaleError} to HTTP 400.
+ */
+export declare class LocaleRegistryService {
+    private readonly locales;
+    private readonly policy;
+    constructor(config: I18nPluginConfig);
+    /** All configured locales, in config (display) order. */
+    all(): LocaleDef[];
+    /** One locale by slug, or undefined. */
+    get(slug: string): LocaleDef | undefined;
+    /** The default locale (exactly one exists). */
+    default(): LocaleDef;
+    /**
+     * Resolve a request's locale slug: absent → the default; unknown → 400.
+     * The uniform gate every request-facing path funnels through.
+     */
+    resolve(slug: string | undefined): LocaleDef;
+}
+//# sourceMappingURL=locale-registry.service.d.ts.map

package/dist/lib/locales/services/locale-registry.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-registry.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/locales/services/locale-registry.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAkBtE;;;;;;;GAOG;AACH,qBACa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAEL,MAAM,EAAE,gBAAgB;IAKzD,yDAAyD;IACzD,GAAG,IAAI,SAAS,EAAE;IAIlB,wCAAwC;IACxC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAKxC,+CAA+C;IAC/C,OAAO,IAAI,SAAS;IAIpB;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;CAU/C"}

package/dist/lib/locales/services/locale-registry.service.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleRegistryService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const i18n_constants_1 = require("../../i18n.constants");
+const locale_policy_1 = require("../../domain/locale-policy");
+const errors_1 = require("../../domain/errors");
+const locale_set_1 = require("../../domain/value-objects/locale-set");
+/** Maps a domain {@link Locale} back to the plain wire/config shape. */
+function toDef(locale) {
+    return {
+        slug: locale.slug,
+        name: locale.name,
+        isDefault: locale.isDefault,
+        // Always resolved by the value object (declared or inferred), so every
+        // caller gets a direction rather than having to decide for itself.
+        dir: locale.dir
+    };
+}
+/**
+ * Read access to the validated locale configuration — the runtime authority
+ * every other i18n service consults. It wraps the domain {@link LocaleSet} /
+ * {@link LocalePolicy} (rebuilt from the already-validated config), so every
+ * service resolves locales through the same domain rule; it exposes the plain
+ * {@link LocaleDef} shape its callers expect and maps the domain's
+ * {@link UnknownLocaleError} to HTTP 400.
+ */
+let LocaleRegistryService = class LocaleRegistryService {
+    locales;
+    policy;
+    constructor(config) {
+        this.locales = locale_set_1.LocaleSet.fromDefs(config.locales);
+        this.policy = new locale_policy_1.LocalePolicy(this.locales);
+    }
+    /** All configured locales, in config (display) order. */
+    all() {
+        return this.locales.all().map(toDef);
+    }
+    /** One locale by slug, or undefined. */
+    get(slug) {
+        const locale = this.locales.get(slug);
+        return locale ? toDef(locale) : undefined;
+    }
+    /** The default locale (exactly one exists). */
+    default() {
+        return toDef(this.locales.default());
+    }
+    /**
+     * Resolve a request's locale slug: absent → the default; unknown → 400.
+     * The uniform gate every request-facing path funnels through.
+     */
+    resolve(slug) {
+        try {
+            return toDef(this.policy.resolve(slug));
+        }
+        catch (error) {
+            if (error instanceof errors_1.UnknownLocaleError) {
+                throw new common_1.BadRequestException(error.message);
+            }
+            throw error;
+        }
+    }
+};
+exports.LocaleRegistryService = LocaleRegistryService;
+exports.LocaleRegistryService = LocaleRegistryService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Inject)(i18n_constants_1.I18N_CONFIG)),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], LocaleRegistryService);

package/dist/lib/locales/services/orphaned-locale.checker.d.ts

@@ -0,0 +1,60 @@
+import { type OnApplicationBootstrap } from '@nestjs/common';
+import { type Database } from '@orthacms/database';
+import { type ContentTypeRegistry } from '@orthacms/content-server';
+import type { I18nPluginConfig } from '../../types/locale';
+import { LocaleRegistryService } from './locale-registry.service';
+/** One localized content type's rows in a slug the config no longer declares. */
+export interface OrphanedLocaleReport {
+    /** The content type holding the rows. */
+    typeName: string;
+    /** The unconfigured locale slug. */
+    locale: string;
+    /** How many rows sit in it. */
+    rows: number;
+}
+/**
+ * Boot-time guard against the one locale change that fails silently: **removing
+ * a locale from the config while its rows still exist**.
+ *
+ * Adding a locale is safe and self-announcing — existing groups gain a missing
+ * slot, coverage reports `translated: 0`, the panel shows `entry: null`.
+ * Removing one is neither. Nothing deletes the rows and nothing migrates them,
+ * and from that moment every read path hides them: `?locale=de` becomes a 400
+ * (`resolve` no longer knows the slug), the locale panel iterates the
+ * configured set, the coverage query and the virtual filters restrict to it,
+ * and the batched summary drops them. The German content is intact, reachable
+ * only by `psql`, and the product never mentions it again — including to the
+ * person who made the change, who sees a smaller locale switcher and nothing
+ * else. `LocaleSet.remove` guards the *default* against exactly this class of
+ * mistake, but the plugin never calls it: the config is a literal array, so
+ * there is no removal operation to guard, only a diff nobody computes.
+ *
+ * This computes it, once, at boot: for every localized content type, the
+ * distinct locale slugs present that the config does not declare, with a row
+ * count. Under the default `'fail'` policy the boot aborts, which puts the
+ * decision (migrate the rows, or restore the locale) in front of whoever
+ * changed the config while it is still their change; `'warn'` logs the same
+ * report and continues, for a deployment knowingly mid-migration.
+ *
+ * The scan is one `GROUP BY locale` per localized type, on a column the
+ * `(locale_group_id, locale)` index already covers.
+ */
+export declare class OrphanedLocaleChecker implements OnApplicationBootstrap {
+    private readonly db;
+    private readonly registry;
+    private readonly config;
+    private readonly locales;
+    private readonly logger;
+    constructor(db: Database, registry: ContentTypeRegistry, config: I18nPluginConfig, locales: LocaleRegistryService);
+    /** @inheritdoc */
+    onApplicationBootstrap(): Promise<void>;
+    /**
+     * Rows in an unconfigured locale, per localized content type. Public so a
+     * migration script or an operator endpoint can ask the same question
+     * without re-deriving the rule.
+     */
+    findOrphans(): Promise<OrphanedLocaleReport[]>;
+    /** The unconfigured locales present on one type, with row counts. */
+    private orphansOf;
+}
+//# sourceMappingURL=orphaned-locale.checker.d.ts.map

package/dist/lib/locales/services/orphaned-locale.checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphaned-locale.checker.d.ts","sourceRoot":"","sources":["../../../../src/lib/locales/services/orphaned-locale.checker.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,sBAAsB,EAC9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAGH,KAAK,mBAAmB,EAC3B,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAKlE,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACjC,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBACa,qBAAsB,YAAW,sBAAsB;IAI1C,OAAO,CAAC,QAAQ,CAAC,EAAE;IAErC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACJ,OAAO,CAAC,QAAQ,CAAC,MAAM;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;gBAG1B,EAAE,EAAE,QAAQ,EAE9B,QAAQ,EAAE,mBAAmB,EACR,MAAM,EAAE,gBAAgB,EAC7C,OAAO,EAAE,qBAAqB;IAGnD,kBAAkB;IACZ,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IA4B7C;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAUpD,qEAAqE;YACvD,SAAS;CAwB1B"}

package/dist/lib/locales/services/orphaned-locale.checker.js

@@ -0,0 +1,114 @@
+"use strict";
+var OrphanedLocaleChecker_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrphanedLocaleChecker = 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 content_server_1 = require("@orthacms/content-server");
+const i18n_constants_1 = require("../../i18n.constants");
+const locale_registry_service_1 = require("./locale-registry.service");
+/**
+ * Boot-time guard against the one locale change that fails silently: **removing
+ * a locale from the config while its rows still exist**.
+ *
+ * Adding a locale is safe and self-announcing — existing groups gain a missing
+ * slot, coverage reports `translated: 0`, the panel shows `entry: null`.
+ * Removing one is neither. Nothing deletes the rows and nothing migrates them,
+ * and from that moment every read path hides them: `?locale=de` becomes a 400
+ * (`resolve` no longer knows the slug), the locale panel iterates the
+ * configured set, the coverage query and the virtual filters restrict to it,
+ * and the batched summary drops them. The German content is intact, reachable
+ * only by `psql`, and the product never mentions it again — including to the
+ * person who made the change, who sees a smaller locale switcher and nothing
+ * else. `LocaleSet.remove` guards the *default* against exactly this class of
+ * mistake, but the plugin never calls it: the config is a literal array, so
+ * there is no removal operation to guard, only a diff nobody computes.
+ *
+ * This computes it, once, at boot: for every localized content type, the
+ * distinct locale slugs present that the config does not declare, with a row
+ * count. Under the default `'fail'` policy the boot aborts, which puts the
+ * decision (migrate the rows, or restore the locale) in front of whoever
+ * changed the config while it is still their change; `'warn'` logs the same
+ * report and continues, for a deployment knowingly mid-migration.
+ *
+ * The scan is one `GROUP BY locale` per localized type, on a column the
+ * `(locale_group_id, locale)` index already covers.
+ */
+let OrphanedLocaleChecker = OrphanedLocaleChecker_1 = class OrphanedLocaleChecker {
+    db;
+    registry;
+    config;
+    locales;
+    logger = new common_1.Logger(OrphanedLocaleChecker_1.name);
+    constructor(db, registry, config, locales) {
+        this.db = db;
+        this.registry = registry;
+        this.config = config;
+        this.locales = locales;
+    }
+    /** @inheritdoc */
+    async onApplicationBootstrap() {
+        const orphans = await this.findOrphans();
+        if (!orphans.length)
+            return;
+        const detail = orphans
+            .map((orphan) => `${orphan.typeName}: ${orphan.rows} row(s) in "${orphan.locale}"`)
+            .join('; ');
+        const configured = this.locales
+            .all()
+            .map((locale) => locale.slug)
+            .join(', ');
+        const message = `Entry rows exist in locales this deployment no longer configures ` +
+            `(configured: ${configured}). They are invisible to every read ` +
+            `path — migrate or delete them, or restore the locale. ${detail}`;
+        if ((this.config.orphanedLocales ?? 'fail') === 'warn') {
+            this.logger.warn(message);
+            return;
+        }
+        throw new Error(`${message} Set plugins.i18n.orphanedLocales to 'warn' to boot anyway.`);
+    }
+    /**
+     * Rows in an unconfigured locale, per localized content type. Public so a
+     * migration script or an operator endpoint can ask the same question
+     * without re-deriving the rule.
+     */
+    async findOrphans() {
+        const configured = this.locales.all().map((locale) => locale.slug);
+        const reports = [];
+        for (const type of this.registry.all()) {
+            if (!type.i18n)
+                continue;
+            reports.push(...(await this.orphansOf(type, configured)));
+        }
+        return reports;
+    }
+    /** The unconfigured locales present on one type, with row counts. */
+    async orphansOf(type, configured) {
+        const table = type.table;
+        // Soft-deleted rows are counted too: a restore would bring back a row
+        // in a locale nothing can show, which is the same problem deferred.
+        const rows = (await this.db
+            .select({
+            locale: (0, drizzle_orm_1.sql) `${table['locale']}`,
+            rows: (0, drizzle_orm_1.sql) `count(*)::int`
+        })
+            .from(type.table)
+            .where((0, drizzle_orm_1.notInArray)(table['locale'], configured))
+            .groupBy((0, drizzle_orm_1.sql) `${table['locale']}`));
+        return rows.map((row) => ({
+            typeName: type.name,
+            locale: row.locale,
+            rows: row.rows
+        }));
+    }
+};
+exports.OrphanedLocaleChecker = OrphanedLocaleChecker;
+exports.OrphanedLocaleChecker = OrphanedLocaleChecker = OrphanedLocaleChecker_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__param(1, (0, content_server_1.InjectContentRegistry)()),
+    tslib_1.__param(2, (0, common_1.Inject)(i18n_constants_1.I18N_CONFIG)),
+    tslib_1.__metadata("design:paramtypes", [Object, Function, Object, locale_registry_service_1.LocaleRegistryService])
+], OrphanedLocaleChecker);