@orthacms/i18n-server 0.0.0-reserve.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ortha CMS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @orthacms/i18n-server
+
+Part of [Ortha CMS](https://github.com/ortha-source/ortha-cms).
+
+```sh
+npm install @orthacms/i18n-server
+```

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/** Public API of @orthacms/i18n-server. */
+export { I18nServerPlugin } from './lib/utils/i18n-plugin';
+export type { I18nServerPluginType } from './lib/utils/i18n-plugin';
+export type { I18nPluginConfig, LocaleDef, LocaleDir, OrphanedLocalePolicy } from './lib/types/locale';
+export { LOCALE_DIR, inferLocaleDir } from './lib/i18n.constants';
+export { OrphanedLocaleChecker } from './lib/locales/services/orphaned-locale.checker';
+export type { OrphanedLocaleReport } from './lib/locales/services/orphaned-locale.checker';
+export { I18nModule } from './lib/i18n.module';
+export { LocaleRegistryService } from './lib/locales/services/locale-registry.service';
+export type { LocalesView } from './lib/locales/controllers/list-locales.controller';
+export type { EntryLocaleItem, EntryLocalesView, LocaleSummaryItem, LocaleSummaryView } from './lib/content/services/locale-group.service';
+export type { ContentTypeCoverageView, I18nCoverageView, LocaleCoverageView } from './lib/insights/types/i18n-insights-view';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAE3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,YAAY,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACpE,YAAY,EACR,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,oBAAoB,EACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AACvF,YAAY,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAE3F,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AACvF,YAAY,EAAE,WAAW,EAAE,MAAM,mDAAmD,CAAC;AACrF,YAAY,EACR,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACpB,MAAM,6CAA6C,CAAC;AACrD,YAAY,EACR,uBAAuB,EACvB,gBAAgB,EAChB,kBAAkB,EACrB,MAAM,yCAAyC,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/** Public API of @orthacms/i18n-server. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleRegistryService = exports.I18nModule = exports.OrphanedLocaleChecker = exports.inferLocaleDir = exports.LOCALE_DIR = exports.I18nServerPlugin = void 0;
+var i18n_plugin_1 = require("./lib/utils/i18n-plugin");
+Object.defineProperty(exports, "I18nServerPlugin", { enumerable: true, get: function () { return i18n_plugin_1.I18nServerPlugin; } });
+var i18n_constants_1 = require("./lib/i18n.constants");
+Object.defineProperty(exports, "LOCALE_DIR", { enumerable: true, get: function () { return i18n_constants_1.LOCALE_DIR; } });
+Object.defineProperty(exports, "inferLocaleDir", { enumerable: true, get: function () { return i18n_constants_1.inferLocaleDir; } });
+var orphaned_locale_checker_1 = require("./lib/locales/services/orphaned-locale.checker");
+Object.defineProperty(exports, "OrphanedLocaleChecker", { enumerable: true, get: function () { return orphaned_locale_checker_1.OrphanedLocaleChecker; } });
+var i18n_module_1 = require("./lib/i18n.module");
+Object.defineProperty(exports, "I18nModule", { enumerable: true, get: function () { return i18n_module_1.I18nModule; } });
+var locale_registry_service_1 = require("./lib/locales/services/locale-registry.service");
+Object.defineProperty(exports, "LocaleRegistryService", { enumerable: true, get: function () { return locale_registry_service_1.LocaleRegistryService; } });

package/dist/lib/content/controllers/get-entry-locales.controller.d.ts

@@ -0,0 +1,15 @@
+import type { ContentTypeRegistry } from '@orthacms/content-server';
+import { LocaleGroupService, type EntryLocalesView } from '../services/locale-group.service';
+/**
+ * `GET /api/i18n/content/:typeName/:id/locales` — the locale panel of one
+ * entry: every configured locale with the group's row in it (id, status,
+ * updatedAt) or null. Workspace-scoped like every entry read; gated on
+ * `content:read`.
+ */
+export declare class GetEntryLocalesController {
+    private readonly registry;
+    private readonly groups;
+    constructor(registry: ContentTypeRegistry, groups: LocaleGroupService);
+    get(typeName: string, id: string, workspaceId: string): Promise<EntryLocalesView>;
+}
+//# sourceMappingURL=get-entry-locales.controller.d.ts.map

package/dist/lib/content/controllers/get-entry-locales.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-entry-locales.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/content/controllers/get-entry-locales.controller.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACH,kBAAkB,EAClB,KAAK,gBAAgB,EACxB,MAAM,kCAAkC,CAAC;AAG1C;;;;;GAKG;AACH,qBAGa,yBAAyB;IAG9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,GAAG,CACoB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;CAI/B"}

package/dist/lib/content/controllers/get-entry-locales.controller.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetEntryLocalesController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const content_server_1 = require("@orthacms/content-server");
+const locale_group_service_1 = require("../services/locale-group.service");
+const resolve_type_1 = require("./resolve-type");
+/**
+ * `GET /api/i18n/content/:typeName/:id/locales` — the locale panel of one
+ * entry: every configured locale with the group's row in it (id, status,
+ * updatedAt) or null. Workspace-scoped like every entry read; gated on
+ * `content:read`.
+ */
+let GetEntryLocalesController = class GetEntryLocalesController {
+    registry;
+    groups;
+    constructor(registry, groups) {
+        this.registry = registry;
+        this.groups = groups;
+    }
+    get(typeName, id, workspaceId) {
+        const type = (0, resolve_type_1.resolveI18nType)(this.registry, typeName);
+        return this.groups.entryLocales(type, id, workspaceId);
+    }
+};
+exports.GetEntryLocalesController = GetEntryLocalesController;
+tslib_1.__decorate([
+    (0, common_1.Get)(':typeName/:id/locales'),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Param)('id', common_1.ParseUUIDPipe)),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], GetEntryLocalesController.prototype, "get", null);
+exports.GetEntryLocalesController = GetEntryLocalesController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_READ),
+    (0, common_1.Controller)('i18n/content'),
+    tslib_1.__param(0, (0, content_server_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Function, locale_group_service_1.LocaleGroupService])
+], GetEntryLocalesController);

package/dist/lib/content/controllers/locale-summary.controller.d.ts

@@ -0,0 +1,30 @@
+import type { ContentTypeRegistry } from '@orthacms/content-server';
+import { LocaleSummaryDto } from '../dto/locale-summary.dto';
+import { LocaleGroupService, type LocaleSummaryView } from '../services/locale-group.service';
+/**
+ * `POST /api/i18n/content/:typeName/locale-summary` — the records table's
+ * batched read: per requested translation-group id, the group's live members
+ * with per-row status. Gated on `content:read`, workspace-scoped.
+ *
+ * **A POST that is a read**, because a page of group uuids outgrows a query
+ * string — so it answers `200`, not a `201` that would claim it created
+ * something.
+ *
+ * It still carries `OriginGuard`, unlike the reads that are shaped like reads.
+ * The guard keys off the **verb** a browser sees, not off what the handler
+ * happens to do with it: `POST` is the shape every cross-site form and
+ * `fetch` uses, this route is reachable with nothing but the session cookie,
+ * and "it only reads" is a property of today's handler that no test pins and
+ * a later edit could quietly retract. The guard is free for every legitimate
+ * caller — the admin sends its `Origin`, non-browser clients send none — so
+ * exempting it bought nothing and left the contract ("state-changing routes
+ * are origin-checked") disagreeing with the code. The body's shape is the
+ * batching decision; the guard is not part of it.
+ */
+export declare class LocaleSummaryController {
+    private readonly registry;
+    private readonly groups;
+    constructor(registry: ContentTypeRegistry, groups: LocaleGroupService);
+    summarize(typeName: string, body: LocaleSummaryDto, workspaceId: string): Promise<LocaleSummaryView>;
+}
+//# sourceMappingURL=locale-summary.controller.d.ts.map

package/dist/lib/content/controllers/locale-summary.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-summary.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/content/controllers/locale-summary.controller.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EACH,kBAAkB,EAClB,KAAK,iBAAiB,EACzB,MAAM,kCAAkC,CAAC;AAG1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAGa,uBAAuB;IAG5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAK/C,SAAS,CACc,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,gBAAgB,EACV,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,iBAAiB,CAAC;CAIhC"}

package/dist/lib/content/controllers/locale-summary.controller.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleSummaryController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const content_server_1 = require("@orthacms/content-server");
+const locale_summary_dto_1 = require("../dto/locale-summary.dto");
+const locale_group_service_1 = require("../services/locale-group.service");
+const resolve_type_1 = require("./resolve-type");
+/**
+ * `POST /api/i18n/content/:typeName/locale-summary` — the records table's
+ * batched read: per requested translation-group id, the group's live members
+ * with per-row status. Gated on `content:read`, workspace-scoped.
+ *
+ * **A POST that is a read**, because a page of group uuids outgrows a query
+ * string — so it answers `200`, not a `201` that would claim it created
+ * something.
+ *
+ * It still carries `OriginGuard`, unlike the reads that are shaped like reads.
+ * The guard keys off the **verb** a browser sees, not off what the handler
+ * happens to do with it: `POST` is the shape every cross-site form and
+ * `fetch` uses, this route is reachable with nothing but the session cookie,
+ * and "it only reads" is a property of today's handler that no test pins and
+ * a later edit could quietly retract. The guard is free for every legitimate
+ * caller — the admin sends its `Origin`, non-browser clients send none — so
+ * exempting it bought nothing and left the contract ("state-changing routes
+ * are origin-checked") disagreeing with the code. The body's shape is the
+ * batching decision; the guard is not part of it.
+ */
+let LocaleSummaryController = class LocaleSummaryController {
+    registry;
+    groups;
+    constructor(registry, groups) {
+        this.registry = registry;
+        this.groups = groups;
+    }
+    summarize(typeName, body, workspaceId) {
+        const type = (0, resolve_type_1.resolveI18nType)(this.registry, typeName);
+        return this.groups.summaries(type, body.groupIds, workspaceId);
+    }
+};
+exports.LocaleSummaryController = LocaleSummaryController;
+tslib_1.__decorate([
+    (0, common_1.Post)(':typeName/locale-summary'),
+    (0, common_1.HttpCode)(200),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, locale_summary_dto_1.LocaleSummaryDto, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], LocaleSummaryController.prototype, "summarize", null);
+exports.LocaleSummaryController = LocaleSummaryController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.OriginGuard, identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_READ),
+    (0, common_1.Controller)('i18n/content'),
+    tslib_1.__param(0, (0, content_server_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Function, locale_group_service_1.LocaleGroupService])
+], LocaleSummaryController);

package/dist/lib/content/controllers/resolve-type.d.ts

@@ -0,0 +1,9 @@
+import type { AnyContentType, ContentTypeRegistry } from '@orthacms/content-server';
+/**
+ * Resolve a route's `:typeName` to a registered **i18n** content type: 404
+ * for an unknown name (mirrors the content routes, no enumeration signal
+ * beyond what `/api/content-schema` already serves), 400 for a type that
+ * isn't localized (a caller bug, not a missing resource).
+ */
+export declare function resolveI18nType(registry: ContentTypeRegistry, typeName: string): AnyContentType;
+//# sourceMappingURL=resolve-type.d.ts.map

package/dist/lib/content/controllers/resolve-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-type.d.ts","sourceRoot":"","sources":["../../../../src/lib/content/controllers/resolve-type.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACR,cAAc,EACd,mBAAmB,EACtB,MAAM,0BAA0B,CAAC;AAElC;;;;;GAKG;AACH,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,GACjB,cAAc,CAWhB"}

package/dist/lib/content/controllers/resolve-type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveI18nType = resolveI18nType;
+const common_1 = require("@nestjs/common");
+/**
+ * Resolve a route's `:typeName` to a registered **i18n** content type: 404
+ * for an unknown name (mirrors the content routes, no enumeration signal
+ * beyond what `/api/content-schema` already serves), 400 for a type that
+ * isn't localized (a caller bug, not a missing resource).
+ */
+function resolveI18nType(registry, typeName) {
+    const type = registry.get(typeName);
+    if (!type) {
+        throw new common_1.NotFoundException(`Unknown content type "${typeName}".`);
+    }
+    if (!type.i18n) {
+        throw new common_1.BadRequestException(`Content type "${typeName}" is not localized.`);
+    }
+    return type;
+}

package/dist/lib/content/dto/locale-summary.dto.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Body for `POST /api/i18n/content/:typeName/locale-summary` — the records
+ * table's batched per-page read (POST, not GET: a page of uuids outgrows a
+ * query string). Capped so a request can't fan out unbounded.
+ */
+export declare class LocaleSummaryDto {
+    /** Translation-group ids to summarize (one page's worth). */
+    groupIds: string[];
+}
+//# sourceMappingURL=locale-summary.dto.d.ts.map

package/dist/lib/content/dto/locale-summary.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-summary.dto.d.ts","sourceRoot":"","sources":["../../../../src/lib/content/dto/locale-summary.dto.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,qBAAa,gBAAgB;IACzB,6DAA6D;IAW7D,QAAQ,EAAG,MAAM,EAAE,CAAC;CACvB"}

package/dist/lib/content/dto/locale-summary.dto.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleSummaryDto = void 0;
+const tslib_1 = require("tslib");
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const i18n_constants_1 = require("../../i18n.constants");
+/**
+ * Body for `POST /api/i18n/content/:typeName/locale-summary` — the records
+ * table's batched per-page read (POST, not GET: a page of uuids outgrows a
+ * query string). Capped so a request can't fan out unbounded.
+ */
+class LocaleSummaryDto {
+    /** Translation-group ids to summarize (one page's worth). */
+    groupIds;
+}
+exports.LocaleSummaryDto = LocaleSummaryDto;
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: [String],
+        format: 'uuid',
+        maxItems: i18n_constants_1.LOCALE_SUMMARY_MAX_GROUPS,
+        example: ['c0a80101-7f3d-4c2b-9a1e-6d5b4c3a2f10'],
+        description: `Translation-group ids to summarize — one page's worth, capped at ${i18n_constants_1.LOCALE_SUMMARY_MAX_GROUPS}.`
+    }),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(i18n_constants_1.LOCALE_SUMMARY_MAX_GROUPS),
+    (0, class_validator_1.IsUUID)(undefined, { each: true }),
+    tslib_1.__metadata("design:type", Array)
+], LocaleSummaryDto.prototype, "groupIds", void 0);

package/dist/lib/content/locale-group-lock.d.ts

@@ -0,0 +1,34 @@
+import type { Database } from '@orthacms/database';
+/**
+ * The minimal Drizzle executor the group lock needs: the root client or an
+ * open transaction (both expose `execute`). Mirrors
+ * `@orthacms/workspaces-server`'s `LockExecutor`, so content-server can pass
+ * the entry write's own `tx` straight through.
+ */
+export type LockExecutor = Pick<Database, 'execute'>;
+/**
+ * Serializes writes across the members of one translation group, using a
+ * transaction-scoped Postgres advisory lock keyed on the `locale_group_id`.
+ * The lock auto-releases at commit/rollback.
+ *
+ * **Why an advisory lock rather than ordering the row locks.** The shared-field
+ * sync locks every sibling `FOR UPDATE`, and ordering *that* statement does not
+ * make the group deadlock-free: by the time the sync runs, the transaction
+ * already holds a row lock on the entry being saved, taken by the entries
+ * pipeline's own `UPDATE` before any i18n code ran. Two concurrent saves on two
+ * locales of one record therefore each hold a row the other is about to
+ * request, whatever order the sibling `SELECT … FOR UPDATE` uses — Postgres
+ * detects the cycle and aborts one with `deadlock detected` (SQLSTATE 40P01),
+ * which reaches the client as a 500 on an ordinary save.
+ *
+ * Taking this lock from the extension's `beforeWrite` hook — the first
+ * statement in the write transaction, ahead of the row `UPDATE` — imposes a
+ * total order on the group instead: the second saver waits at the lock, and by
+ * the time it proceeds the first has committed and released every row. Waiting
+ * is the correct outcome for two edits to one record; deadlocking is not.
+ *
+ * Exclusive rather than shared because every taker is a writer: a save reaches
+ * here only when it has shared columns or a syncing relation to propagate.
+ */
+export declare function lockLocaleGroup(executor: LockExecutor, localeGroupId: string): Promise<unknown>;
+//# sourceMappingURL=locale-group-lock.d.ts.map

package/dist/lib/content/locale-group-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-group-lock.d.ts","sourceRoot":"","sources":["../../../src/lib/content/locale-group-lock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAUrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,YAAY,EACtB,aAAa,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAIlB"}

package/dist/lib/content/locale-group-lock.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockLocaleGroup = lockLocaleGroup;
+const drizzle_orm_1 = require("drizzle-orm");
+/**
+ * A private lock class (the first `pg_advisory_xact_lock` key) namespacing the
+ * per-translation-group advisory lock below, so its hashed group-id key can't
+ * collide with any other advisory lock the app takes (workspace content `WK`,
+ * revision append `RE`, relation append `RL`). Arbitrary but fixed.
+ */
+const LOCALE_GROUP_LOCK_CLASS = 0x4c47; // 'LG'
+/**
+ * Serializes writes across the members of one translation group, using a
+ * transaction-scoped Postgres advisory lock keyed on the `locale_group_id`.
+ * The lock auto-releases at commit/rollback.
+ *
+ * **Why an advisory lock rather than ordering the row locks.** The shared-field
+ * sync locks every sibling `FOR UPDATE`, and ordering *that* statement does not
+ * make the group deadlock-free: by the time the sync runs, the transaction
+ * already holds a row lock on the entry being saved, taken by the entries
+ * pipeline's own `UPDATE` before any i18n code ran. Two concurrent saves on two
+ * locales of one record therefore each hold a row the other is about to
+ * request, whatever order the sibling `SELECT … FOR UPDATE` uses — Postgres
+ * detects the cycle and aborts one with `deadlock detected` (SQLSTATE 40P01),
+ * which reaches the client as a 500 on an ordinary save.
+ *
+ * Taking this lock from the extension's `beforeWrite` hook — the first
+ * statement in the write transaction, ahead of the row `UPDATE` — imposes a
+ * total order on the group instead: the second saver waits at the lock, and by
+ * the time it proceeds the first has committed and released every row. Waiting
+ * is the correct outcome for two edits to one record; deadlocking is not.
+ *
+ * Exclusive rather than shared because every taker is a writer: a save reaches
+ * here only when it has shared columns or a syncing relation to propagate.
+ */
+function lockLocaleGroup(executor, localeGroupId) {
+    return executor.execute((0, drizzle_orm_1.sql) `select pg_advisory_xact_lock(${LOCALE_GROUP_LOCK_CLASS}, hashtext(${localeGroupId}))`);
+}

package/dist/lib/content/services/entry-locale-extension.service.d.ts

@@ -0,0 +1,188 @@
+import { type SQL } from 'drizzle-orm';
+import { type Database } from '@orthacms/database';
+import { EntryValidationService, RelationLinkService, type AnyContentType, type ContentEntryExtension, type EntryFilterExtension, type EntryScopeParams, type EntryTransaction, type EntryWriteContext, type EntryWriteFanout } from '@orthacms/content-server';
+import { LocaleRegistryService } from '../../locales/services/locale-registry.service';
+/**
+ * The i18n plugin's binding of content-server's `CONTENT_ENTRY_EXTENSION`
+ * port — where every locale *behavior* lives, so the content library itself
+ * stays locale-agnostic:
+ *
+ * - **List scoping** — the active-locale filter (strict; the default locale
+ *   when the request names none), plus the relation picker's
+ *   `localeFallback=default` union.
+ * - **Create stamping** — validates the requested slug and stamps the
+ *   `locale` envelope column (the group id comes from the column default: a
+ *   plain create starts its own translation group).
+ * - **Shared-field sync** — on update, non-`localized` field values propagate
+ *   to every sibling row of the translation group, inside the same
+ *   transaction; published siblings are re-validated so a draft edit can
+ *   never silently invalidate live content. The rewritten siblings are handed
+ *   back to the entries pipeline, which appends a **revision** for each — their
+ *   values changed, so their history has to say so.
+ * - **Virtual filters** — `hasLocale` / `missingLocale` / `localeCount`,
+ *   resolved to EXISTS / count subqueries over the group (ridden by the
+ *   `(locale_group_id, locale)` unique index).
+ *
+ * Every method no-ops for non-i18n types, as the port contract requires.
+ */
+export declare class EntryLocaleExtensionService implements ContentEntryExtension {
+    private readonly db;
+    private readonly locales;
+    private readonly validation;
+    private readonly relations;
+    constructor(db: Database, locales: LocaleRegistryService, validation: EntryValidationService, relations: RelationLinkService);
+    /** @inheritdoc */
+    listScope(type: AnyContentType, workspaceId: string, params: EntryScopeParams): SQL | undefined;
+    /**
+     * @inheritdoc
+     *
+     * Stamps the validated `locale` (defaulting when absent). When a
+     * `localeGroupId` is given the new row **joins that existing group** (a
+     * sibling translation) — verified to name a real group in the workspace
+     * first (else 404), so a typo can't spawn a stray one-row group. Absent →
+     * the column default (`gen_random_uuid()`) starts a fresh group.
+     */
+    createColumns(type: AnyContentType, workspaceId: string, params: EntryScopeParams): Promise<Record<string, unknown>>;
+    /**
+     * Assert a translation group has ≥1 live row in this workspace, so a
+     * sibling attaches to a real group. Runs before the create transaction —
+     * the (benign) TOCTOU window is covered by the row staying valid and the
+     * `(locale_group_id, locale)` unique index still guarding duplicates.
+     */
+    private assertGroupExists;
+    /**
+     * @inheritdoc
+     *
+     * Takes the translation group's advisory lock, ahead of every row lock the
+     * write will acquire. See {@link lockLocaleGroup} for why ordering the
+     * sibling `FOR UPDATE` cannot replace this: the edited row is already
+     * locked by the pipeline's own `UPDATE` before any i18n code runs, so two
+     * saves in one group invert their lock order no matter how the sync sorts
+     * its siblings.
+     *
+     * No group id means a create starting a fresh group — nothing to contend
+     * on, so nothing to lock.
+     */
+    beforeWrite(tx: EntryTransaction, type: AnyContentType, params: EntryScopeParams): Promise<void>;
+    /** @inheritdoc */
+    afterUpdate(tx: EntryTransaction, type: AnyContentType, row: Record<string, unknown>, values: Record<string, unknown>, workspaceId: string, context: EntryWriteContext): Promise<Record<string, unknown>[]>;
+    /** @inheritdoc */
+    describeFanout(type: AnyContentType, entryId: string, values: Record<string, unknown>, workspaceId: string): Promise<EntryWriteFanout | undefined>;
+    /**
+     * Whether this field's value reaches the row's siblings when it is saved —
+     * the predicate behind {@link describeFanout}, stated once against the same
+     * three rules {@link propagateToSiblings} applies.
+     *
+     * It is broader than {@link sharedColumns}, deliberately: that method
+     * answers "which columns copy across verbatim", because shared columns,
+     * mirrored FKs and join-backed link sets are *applied* by three different
+     * mechanisms. To a person being told what their change will do, the three
+     * are one fact — the value they set here lands over there.
+     *
+     * A **mirrored** relation counts even though each sibling ends up holding a
+     * different id: the sibling's link is being repointed at the record this
+     * save chose, which is a change to that row whatever id expresses it.
+     */
+    private travelsToSiblings;
+    /**
+     * Push this row's state onto every sibling in its translation group, and
+     * return the rows actually rewritten (the pipeline appends a revision for
+     * each — their content moved in this transaction, and without a version
+     * their history would skip the change and a later restore would silently
+     * undo it).
+     *
+     * Three kinds of state travel, each computed once and applied per sibling:
+     * shared **columns** (identical everywhere), **mirrored** single-relation
+     * FKs (resolved into each sibling's own locale), and the **link sets** of
+     * join-backed relations. A sibling whose every one of those already matches
+     * is left completely untouched — that guard is what stops one save
+     * re-versioning the whole group.
+     */
+    private propagateToSiblings;
+    /**
+     * Fill a **newly created** sibling's propagating relations from the group
+     * it just joined — the half of the sync that runs inward.
+     *
+     * A translation is created through the ordinary create route with a
+     * `localeGroupId`, and a create body carries no relation links at all: they
+     * are join-backed (never in the values bag) or per-locale (deliberately
+     * dropped by the client, since the source's id names another language's
+     * row). So without this a translation is born with none of the record's
+     * links, which is exactly the manual per-locale re-linking this sync
+     * exists to remove.
+     *
+     * The donor is one existing sibling — any of them agree on a shared link,
+     * and a mirrored one resolves through the same translation group whichever
+     * is asked — picked deterministically (the default locale where the group
+     * has it) so two creates never inherit from different rows.
+     *
+     * Columns it derives are also written back onto `row` **in place**: the
+     * caller snapshots that object as the new entry's first revision *after*
+     * this call, so a database-only write would leave version 1 describing
+     * something the row never held.
+     */
+    private inheritRelationsFromGroup;
+    /**
+     * Per locale, the **mirrored** single-relation FK columns a sibling in that
+     * locale should hold: the source's linked record, resolved to that record's
+     * own translation in the sibling's language.
+     *
+     * An unresolvable link becomes `null` rather than being skipped. Leaving
+     * the sibling's existing value would keep it pointing at the *previous*
+     * record's translation — silently wrong data, which is worse than an empty
+     * field that the editor can see and the publish gate can block on.
+     */
+    private mirroredColumnsByLocale;
+    /**
+     * Per join-backed relation field, per locale, the ordered link ids a
+     * sibling in that locale should hold.
+     *
+     * A **shared** relation hands every sibling the source's ids verbatim — the
+     * target has no locales, so there is one right row for the whole group. A
+     * **mirrored** one maps each id through its translation group into the
+     * sibling's language, preserving the source's order and dropping links
+     * whose target has no translation there (a content gap on the target, not a
+     * reason to fail this save).
+     */
+    private linkSetsByLocale;
+    /** @inheritdoc */
+    filterExtension(type: AnyContentType): EntryFilterExtension | undefined;
+    /**
+     * Translate one virtual locale rule into SQL. All three fields quantify
+     * over the row's translation group via a self-EXISTS/count subquery,
+     * workspace-scoped, (on paranoid types) live-rows-only, and **restricted to
+     * the configured locale set** — the same restriction the coverage query
+     * applies (`configuredScope`).
+     *
+     * That last one is what keeps the records table and the Translation
+     * coverage card telling the same story. A row in a slug the host has since
+     * dropped is not coverage of anything: coverage filters it out, so leaving
+     * it in here made `localeCount` count higher than the number of configured
+     * locales, and a record the card reported as fully localized answered
+     * neither `localeCount eq 3` (the configured total) nor any `hasLocale`
+     * question consistent with it. Two views of one record, disagreeing.
+     *
+     * `missingLocale in [a, b]` is a `notExists` over the union, so it means
+     * "missing **all** of these", not "missing any" — the union has no matching
+     * sibling only when every named locale is absent. It is the useful reading
+     * for the records table ("show me what has none of my target languages");
+     * "missing any" is expressed as an `or` of `missingLocale eq` rules.
+     */
+    private resolveLocaleRule;
+    /**
+     * The column bag of the fields whose value is **identical in every locale**,
+     * drawn from a save's coerced values — the part of the sync that is the
+     * same for every sibling.
+     *
+     * Scalars and media qualify unless marked `localized`. A relation qualifies
+     * only when it is column-backed *and* {@link RELATION_LOCALE_SYNC.Shared}:
+     * a join-backed relation has no column to copy (its links go through
+     * {@link linkSetsByLocale}), and a mirrored one stores a different id in
+     * every locale by design (see {@link mirroredColumnsByLocale}), so copying
+     * one verbatim would be exactly the cross-locale link the writer rejects.
+     *
+     * `null` when the type has no such field at all.
+     */
+    private sharedColumns;
+}
+//# sourceMappingURL=entry-locale-extension.service.d.ts.map

package/dist/lib/content/services/entry-locale-extension.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-locale-extension.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/content/services/entry-locale-extension.service.ts"],"names":[],"mappings":"AAMA,OAAO,EAYH,KAAK,GAAG,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EACH,sBAAsB,EACtB,mBAAmB,EAMnB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAE1B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACxB,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAuCvF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBACa,2BAA4B,YAAW,qBAAqB;IAE/C,OAAO,CAAC,QAAQ,CAAC,EAAE;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAK3B,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAPS,EAAE,EAAE,QAAQ,EAC9B,OAAO,EAAE,qBAAqB,EAC9B,UAAU,EAAE,sBAAsB,EAKlC,SAAS,EAAE,mBAAmB;IAGnD,kBAAkB;IAClB,SAAS,CACL,IAAI,EAAE,cAAc,EACpB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,gBAAgB,GACzB,GAAG,GAAG,SAAS;IAmClB;;;;;;;;OAQG;IACG,aAAa,CACf,IAAI,EAAE,cAAc,EACpB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAgBnC;;;;;OAKG;YACW,iBAAiB;IAwB/B;;;;;;;;;;;;OAYG;IACG,WAAW,CACb,EAAE,EAAE,gBAAgB,EACpB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,gBAAgB,GACzB,OAAO,CAAC,IAAI,CAAC;IAKhB,kBAAkB;IACZ,WAAW,CACb,EAAE,EAAE,gBAAgB,EACpB,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,iBAAiB,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAmBrC,kBAAkB;IACZ,cAAc,CAChB,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAkDxC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;;;;;;;;;OAaG;YACW,mBAAmB;IAiMjC;;;;;;;;;;;;;;;;;;;;;OAqBG;YACW,yBAAyB;IAmEvC;;;;;;;;;OASG;YACW,uBAAuB;IA0CrC;;;;;;;;;;OAUG;YACW,gBAAgB;IA6C9B,kBAAkB;IAClB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,oBAAoB,GAAG,SAAS;IAcvE;;;;;;;;;;;;;;;;;;;;OAoBG;YACW,iBAAiB;IAmE/B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,aAAa;CAoBxB"}