@byline/core 3.0.1 → 3.0.2

package/dist/@types/collection-types.d.ts

@@ -360,6 +360,10 @@ export interface BeforeUpdateContext {
         sourceLocale: string;
         targetLocale: string;
     };
+    /** Set only when the update originates from a Delete-Locale operation. */
+    deleteLocale?: {
+        locale: string;
+    };
 }
 /**
  * Context passed to `afterUpdate` hooks.
@@ -385,6 +389,10 @@ export interface AfterUpdateContext {
         sourceLocale: string;
         targetLocale: string;
     };
+    /** Mirrors `BeforeUpdateContext.deleteLocale`. */
+    deleteLocale?: {
+        locale: string;
+    };
 }
 /**
  * Context passed to `beforeStatusChange` / `afterStatusChange` hooks.

package/dist/@types/db-types.d.ts

@@ -373,6 +373,24 @@ export interface IDocumentCommands {
     softDeleteDocument(params: {
         document_id: string;
     }): Promise<number>;
+    /**
+     * Remove one content locale's data from a document by writing a new
+     * immutable version that carries forward every store row except the target
+     * locale's (the `'all'` rows and all other locales are kept). The prior
+     * version still holds the deleted locale, so the operation is recoverable.
+     *
+     * `status` is the new version's status (the lifecycle service passes the
+     * workflow default — a fresh draft). Returns the new and previous version
+     * ids, or `null` when the document has no current version.
+     */
+    deleteDocumentLocale(params: {
+        documentId: string;
+        locale: string;
+        status?: string;
+    }): Promise<{
+        newVersionId: string;
+        previousVersionId: string;
+    } | null>;
     /**
      * Write the fractional-index `order_key` on a single `byline_documents`
      * row. Used by the reorder server fn for `orderable: true` collections.

package/dist/services/collection-bootstrap.test.node.js

@@ -42,6 +42,7 @@ function createMockDb(options) {
                 setDocumentStatus: vi.fn(fail),
                 archivePublishedVersions: vi.fn(fail),
                 softDeleteDocument: vi.fn(fail),
+                deleteDocumentLocale: vi.fn(fail),
                 setOrderKey: vi.fn(fail),
             },
             counters: {
@@ -183,6 +184,7 @@ describe('ensureCollections', () => {
                     setDocumentStatus: vi.fn(),
                     archivePublishedVersions: vi.fn(),
                     softDeleteDocument: vi.fn(),
+                    deleteDocumentLocale: vi.fn(),
                     setOrderKey: vi.fn(),
                 },
                 counters: {

package/dist/services/discover-counter-groups.test.node.js

@@ -27,6 +27,7 @@ function makeAdapter(options) {
                 setDocumentStatus: vi.fn(fail),
                 archivePublishedVersions: vi.fn(fail),
                 softDeleteDocument: vi.fn(fail),
+                deleteDocumentLocale: vi.fn(fail),
                 setOrderKey: vi.fn(fail),
             },
             counters: {

package/dist/services/document-lifecycle.d.ts

@@ -135,6 +135,13 @@ export interface CopyToLocaleResult {
      */
     fieldsUpdated: number;
 }
+export interface DeleteLocaleResult {
+    documentId: string;
+    /** The newly-created version that omits the deleted locale's content. */
+    documentVersionId: string;
+    /** The content locale that was removed. */
+    locale: string;
+}
 export interface DuplicateDocumentResult {
     /** The newly-created document's id. */
     documentId: string;
@@ -421,3 +428,32 @@ export declare function copyToLocale(ctx: DocumentLifecycleContext, params: {
     targetLocale: string;
     overwrite: boolean;
 }): Promise<CopyToLocaleResult>;
+/**
+ * Remove one content locale's data from a document, in place on the same
+ * document, by writing a new immutable version that omits that locale's
+ * store rows (every other locale and all non-localized `'all'` rows are
+ * carried forward by the storage primitive).
+ *
+ * The default content locale is the document's anchor (path + source_locale)
+ * and can never be removed — rejected up front. The new version lands as the
+ * workflow's default status (a fresh draft), exactly like `copyToLocale`: the
+ * previously-published version keeps serving — including the locale being
+ * removed — until the new version is reviewed and published. The deletion is
+ * recoverable: the prior version still holds the locale, so restoring it
+ * brings the content back.
+ *
+ * Flow:
+ *   1. `assertActorCanPerform('update')` — removing a translation is an edit.
+ *   2. Reject `locale === defaultLocale`.
+ *   3. Read the document in the target locale (validates existence; supplies
+ *      `originalData` for hooks and the availability set for the presence
+ *      check).
+ *   4. Reject when the locale has no content to delete.
+ *   5. `hooks.beforeUpdate({ …, deleteLocale: { locale } })`.
+ *   6. `db.commands.documents.deleteDocumentLocale({ …, status: default })`.
+ *   7. `hooks.afterUpdate({ …, deleteLocale: { locale } })`.
+ */
+export declare function deleteLocale(ctx: DocumentLifecycleContext, params: {
+    documentId: string;
+    locale: string;
+}): Promise<DeleteLocaleResult>;

package/dist/services/document-lifecycle.js

@@ -1341,3 +1341,107 @@ export async function copyToLocale(ctx, params) {
         };
     });
 }
+// ---------------------------------------------------------------------------
+// deleteLocale
+// ---------------------------------------------------------------------------
+/**
+ * Remove one content locale's data from a document, in place on the same
+ * document, by writing a new immutable version that omits that locale's
+ * store rows (every other locale and all non-localized `'all'` rows are
+ * carried forward by the storage primitive).
+ *
+ * The default content locale is the document's anchor (path + source_locale)
+ * and can never be removed — rejected up front. The new version lands as the
+ * workflow's default status (a fresh draft), exactly like `copyToLocale`: the
+ * previously-published version keeps serving — including the locale being
+ * removed — until the new version is reviewed and published. The deletion is
+ * recoverable: the prior version still holds the locale, so restoring it
+ * brings the content back.
+ *
+ * Flow:
+ *   1. `assertActorCanPerform('update')` — removing a translation is an edit.
+ *   2. Reject `locale === defaultLocale`.
+ *   3. Read the document in the target locale (validates existence; supplies
+ *      `originalData` for hooks and the availability set for the presence
+ *      check).
+ *   4. Reject when the locale has no content to delete.
+ *   5. `hooks.beforeUpdate({ …, deleteLocale: { locale } })`.
+ *   6. `db.commands.documents.deleteDocumentLocale({ …, status: default })`.
+ *   7. `hooks.afterUpdate({ …, deleteLocale: { locale } })`.
+ */
+export async function deleteLocale(ctx, params) {
+    return withLogContext({ domain: 'services', module: 'lifecycle', function: 'deleteLocale' }, async () => {
+        const { db, definition, collectionId, collectionPath, defaultLocale } = ctx;
+        assertActorCanPerform(ctx.requestContext, collectionPath, 'update');
+        // The default locale anchors the document's path and source_locale —
+        // it cannot be deleted (the other locales fall back to it).
+        if (params.locale === defaultLocale) {
+            throw ERR_VALIDATION({
+                message: `cannot delete the default content locale ('${defaultLocale}')`,
+                details: { documentId: params.documentId, locale: params.locale, collectionPath },
+            }).log(ctx.logger);
+        }
+        // Read the document in the locale being removed — validates existence,
+        // supplies originalData for hooks, and the availability set for the
+        // content-presence check below.
+        const target = await db.queries.documents.getDocumentById({
+            collection_id: collectionId,
+            document_id: params.documentId,
+            locale: params.locale,
+            reconstruct: true,
+            lenient: true,
+            requestContext: ctx.requestContext,
+        });
+        if (target == null) {
+            throw ERR_NOT_FOUND({
+                message: 'document not found',
+                details: { documentId: params.documentId, collectionPath },
+            }).log(ctx.logger);
+        }
+        const targetRecord = target;
+        // `_availableVersionLocales` is the derived (path-coverage) set; it is
+        // the same source the editor's Delete-Locale picker is built from, so a
+        // locale offered in the UI resolves here. A partially-translated locale
+        // that never reached full coverage is not deletable through this path.
+        const available = targetRecord._availableVersionLocales ?? [];
+        if (!available.includes(params.locale)) {
+            throw ERR_NOT_FOUND({
+                message: `locale '${params.locale}' has no content to delete`,
+                details: { documentId: params.documentId, locale: params.locale, collectionPath },
+            }).log(ctx.logger);
+        }
+        const hooks = definition.hooks;
+        const deleteLocaleMarker = { locale: params.locale };
+        const originalData = targetRecord.fields ?? {};
+        await invokeHook(hooks?.beforeUpdate, {
+            data: originalData,
+            originalData,
+            collectionPath,
+            deleteLocale: deleteLocaleMarker,
+        });
+        const result = await db.commands.documents.deleteDocumentLocale({
+            documentId: params.documentId,
+            locale: params.locale,
+            status: getDefaultStatus(definition),
+        });
+        if (result == null) {
+            throw ERR_NOT_FOUND({
+                message: 'document not found',
+                details: { documentId: params.documentId, collectionPath },
+            }).log(ctx.logger);
+        }
+        await invokeHook(hooks?.afterUpdate, {
+            data: originalData,
+            originalData,
+            collectionPath,
+            documentId: params.documentId,
+            documentVersionId: result.newVersionId,
+            deleteLocale: deleteLocaleMarker,
+        });
+        return {
+            documentId: params.documentId,
+            documentVersionId: result.newVersionId,
+            locale: params.locale,
+        };
+    });
+}

package/dist/services/document-lifecycle.test.node.js

@@ -47,6 +47,7 @@ function createMockDb() {
                 setDocumentStatus,
                 archivePublishedVersions,
                 softDeleteDocument,
+                deleteDocumentLocale: vi.fn(),
                 setOrderKey: vi.fn(),
             },
             counters: {

package/dist/services/field-upload.test.node.js

@@ -56,6 +56,7 @@ function createMockDb() {
                 setDocumentStatus: vi.fn(),
                 archivePublishedVersions: vi.fn(),
                 softDeleteDocument: vi.fn(),
+                deleteDocumentLocale: vi.fn(),
                 setOrderKey: vi.fn(),
             },
             counters: {

package/dist/services/populate.test.node.js

@@ -144,6 +144,7 @@ function makeMockAdapter(store = {}, pathByCollectionId = {}) {
                 setDocumentStatus: vi.fn(),
                 archivePublishedVersions: vi.fn(),
                 softDeleteDocument: vi.fn(),
+                deleteDocumentLocale: vi.fn(),
                 setOrderKey: vi.fn(),
             },
             counters: {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/core",
   "private": false,
   "license": "MPL-2.0",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -79,7 +79,7 @@
     "sharp": "^0.34.5",
     "uuid": "^14.0.0",
     "zod": "^4.4.3",
-    "@byline/auth": "3.0.1"
+    "@byline/auth": "3.0.2"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.15",