@taon-dev/cms 21.0.22 → 21.0.24

package/ts-source/websql-code-prod/taon-cms-content/taon-cms-content.repository.ts

@@ -21,9 +21,10 @@ import type { TaonCmsContentRevisionEntity } from '../taon-cms-content-revision/
 import { TaonCmsContentRevisionRepository } from '../taon-cms-content-revision/taon-cms-content-revision.repository';
 import { TaonCmsContentTagRepository } from '../taon-cms-content-tag/taon-cms-content-tag.repository';
 import { TaonCmsTagRepository } from '../taon-cms-tag/taon-cms-tag.repository';
+import { TaonCmsContentAssetEntity } from '../taon-cms-content-asset/taon-cms-content-asset.entity';
 import { TaonCmsContentEntity } from './taon-cms-content.entity';
 import { TaonCmsContentType } from './taon-cms-content.models';
-import type { TaonCmsContentFields, TaonCmsContentSnapshot, TaonCmsCreateContent, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, } from './taon-cms-content.models';
+import type { TaonCmsContentFields, TaonCmsContentSnapshot, TaonCmsCreateContent, TaonCmsRestoreContent, TaonCmsUpdateContent, TaonCmsPermissionConfiguration, TaonCmsPostVersionKind, TaonCmsPostVersionLinks, TaonCmsVisibilityConfiguration, } from './taon-cms-content.models';
 import { contentError, requireContentId, requireContentVersion, validateContentInput, } from './taon-cms-content.validation';
 @TaonRepository({
     className: 'TaonCmsContentRepository',
@@ -41,46 +42,170 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
             return this.taonCmsContentTagRepository.findTagIds(id, manager);
         });
     }
+    async getVisibilityConfiguration(id: number): Promise<TaonCmsVisibilityConfiguration> {
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => {
+            const content = await this.requireContent(id, manager);
+            return this.resolveVisibilityConfiguration(content, manager);
+        });
+    }
     async createContent(input: TaonCmsCreateContent): Promise<TaonCmsContentEntity> {
         validateContentInput(input, true);
         return this.connection.transaction('SERIALIZABLE', manager => this.createContentWithManager(input, manager));
     }
-    async duplicateContent(id: number): Promise<TaonCmsContentEntity> {
+    private async resolveVisibilityConfiguration(post: TaonCmsContentEntity, manager: EntityManager): Promise<TaonCmsVisibilityConfiguration> {
+        const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+        let childId = post.id;
+        const visited = new Set<number>([childId]);
+        while (true) {
+            const parents = await repository.find({
+                where: { relatedPosts: { id: childId } },
+            });
+            if (parents.length > 1) {
+                contentError('A post cannot have multiple parent posts.', 409);
+            }
+            const parent = parents[0];
+            if (!parent) {
+                return { status: this.contentStatus(post.status), source: null };
+            }
+            if (visited.has(parent.id)) {
+                contentError('Related posts cannot contain circular relationships.', 409);
+            }
+            visited.add(parent.id);
+            if (parent.applyVisibilityToRelatedPosts) {
+                return {
+                    status: this.contentStatus(parent.status),
+                    source: { id: parent.id, title: parent.title },
+                };
+            }
+            childId = parent.id;
+        }
+    }
+    async duplicateContent(id: number, includeChildren: boolean, copyStorageObject: (key: string) => Promise<string>, deleteStorageObject: (key: string) => Promise<void>): Promise<TaonCmsContentEntity> {
         requireContentId(id);
-        return this.connection.transaction('SERIALIZABLE', async (manager) => {
-            const source = await this.requireContent(id, manager);
-            const snapshot = await this.snapshotOf(source, manager);
-            const configuration = await this.resolvePermissionConfiguration(source, manager);
-            const titleSuffix = source.title.match(/\s+COPY(\d+)$/i);
-            const slugSuffix = source.slug.match(/-copy(\d+)$/i);
-            const baseTitle = source.title.replace(/(?:\s+COPY\d+)+$/i, '');
-            const baseSlug = source.slug.replace(/(?:-copy\d+)+$/i, '');
-            let number = Math.max(Number(titleSuffix?.[1] ?? 0), Number(slugSuffix?.[1] ?? 0)) +
-                1;
-            const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
-            while (Number.isSafeInteger(number)) {
-                const title = `${baseTitle} COPY${number}`;
-                const slug = `${baseSlug}-copy${number}`;
-                const existing = await repository.findOne({
-                    where: [{ title }, { slug }],
-                });
-                if (!existing) {
-                    return this.createContentWithManager({
-                        ...snapshot,
-                        title,
-                        slug,
-                        relatedPostIds: [],
+        const copiedKeys: string[] = [];
+        try {
+            return await this.connection.transaction('SERIALIZABLE', async (manager) => {
+                const processed = new Set<number>();
+                const duplicateNode = async (source: TaonCmsContentEntity, inheritedStatus?: TaonCmsContentFields['status']): Promise<TaonCmsContentEntity> => {
+                    if (processed.has(source.id)) {
+                        contentError('The related post hierarchy contains a cycle or duplicate post.', 409);
+                    }
+                    processed.add(source.id);
+                    const sourcePost = await this.requireContent(source.id, manager);
+                    const snapshot = await this.snapshotOf(sourcePost, manager);
+                    const configuration = await this.resolvePermissionConfiguration(sourcePost, manager);
+                    const children: TaonCmsContentEntity[] = [];
+                    const status = inheritedStatus ?? snapshot.status;
+                    const descendantStatus = inheritedStatus ??
+                        (snapshot.applyVisibilityToRelatedPosts ? status : undefined);
+                    if (includeChildren) {
+                        for (const child of sourcePost.relatedPosts ?? []) {
+                            children.push(await duplicateNode(child, descendantStatus));
+                        }
+                    }
+                    const titleAndSlug = await this.nextCopyTitleAndSlug(sourcePost.title, sourcePost.slug, manager);
+                    const copiedSnapshot = { ...snapshot, status };
+                    const copiedAssetKeys = new Map<string, string>();
+                    for (const field of [
+                        'videoKey',
+                        'audioKey',
+                        'attachmentKey',
+                        'thumbnailKey',
+                    ] as const) {
+                        const key = copiedSnapshot[field];
+                        if (key && !key.startsWith('cms-placeholder:')) {
+                            let copiedKey = copiedAssetKeys.get(key);
+                            if (!copiedKey) {
+                                copiedKey = await copyStorageObject(key);
+                                copiedKeys.push(copiedKey);
+                                copiedAssetKeys.set(key, copiedKey);
+                            }
+                            copiedSnapshot[field] = copiedKey;
+                        }
+                    }
+                    const duplicate = await this.createContentWithManager({
+                        ...copiedSnapshot,
+                        ...titleAndSlug,
+                        relatedPostIds: children.map(child => child.id),
                         applicationHook: null,
                         permissionIds: configuration.permissions.map(permission => permission.id),
                     }, manager);
+                    const assetRepository = manager.getRepository<TaonCmsContentAssetEntity>(TaonCmsContentAssetEntity);
+                    const sourceAssets = await assetRepository.find({
+                        where: { contentId: sourcePost.id },
+                    });
+                    for (const asset of sourceAssets) {
+                        const copiedKey = copiedAssetKeys.get(asset.key);
+                        if (!copiedKey) {
+                            continue;
+                        }
+                        await assetRepository.save(assetRepository.create({
+                            version: 1,
+                            contentId: duplicate.id,
+                            type: asset.type,
+                            storageProvider: asset.storageProvider,
+                            bucket: asset.bucket,
+                            key: copiedKey,
+                            originalFilename: asset.originalFilename,
+                            mimeType: asset.mimeType,
+                            size: asset.size,
+                            durationSeconds: asset.durationSeconds,
+                            metadata: asset.metadata,
+                            createdAt: new Date(),
+                        }));
+                    }
+                    return duplicate;
+                };
+                return duplicateNode(await this.requireContent(id, manager));
+            });
+        }
+        catch (error) {
+            const cleanupErrors: unknown[] = [];
+            for (const key of copiedKeys.reverse()) {
+                try {
+                    await deleteStorageObject(key);
+                }
+                catch (cleanupError) {
+                    cleanupErrors.push(cleanupError);
                 }
-                number += 1;
             }
-            contentError('No available copy number could be generated.', 409);
-        });
+            if (cleanupErrors.length) {
+                console.error('[taon-cms-content] Unable to clean up duplicated media', cleanupErrors);
+                contentError('Post duplication failed and one or more copied asset files could not be removed.', 500);
+            }
+            throw error;
+        }
+    }
+    private async nextCopyTitleAndSlug(title: string, slug: string, manager: EntityManager): Promise<{
+        title: string;
+        slug: string;
+    }> {
+        const titleSuffix = title.match(/\s+COPY(\d+)$/i);
+        const slugSuffix = slug.match(/-copy(\d+)$/i);
+        const baseTitle = title.replace(/(?:\s+COPY\d+)+$/i, '');
+        const baseSlug = slug.replace(/(?:-copy\d+)+$/i, '');
+        let number = Math.max(Number(titleSuffix?.[1] ?? 0), Number(slugSuffix?.[1] ?? 0)) +
+            1;
+        const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+        while (Number.isSafeInteger(number)) {
+            const copyTitle = `${baseTitle} COPY${number}`;
+            const copySlug = `${baseSlug}-copy${number}`;
+            const existing = await repository.findOne({
+                where: [{ title: copyTitle }, { slug: copySlug }],
+            });
+            if (!existing) {
+                return { title: copyTitle, slug: copySlug };
+            }
+            number += 1;
+        }
+        contentError('No available copy number could be generated.', 409);
     }
     private async createContentWithManager(input: TaonCmsCreateContent, manager: EntityManager): Promise<TaonCmsContentEntity> {
         const fields = this.contentFields(input);
+        if (fields.status === 'published' && fields.publishedAt === null) {
+            fields.publishedAt = new Date();
+        }
         const tagIds = [...new Set(input.tagIds ?? [])];
         const relatedPostIds = [...new Set(input.relatedPostIds ?? [])];
         const permissionIds = [...new Set(input.permissionIds ?? [])];
@@ -96,6 +221,9 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         }));
         await this.taonCmsContentTagRepository.replaceTags(content.id, tagIds, manager);
         await this.replaceRelatedPosts(content.id, relatedPostIds, [], manager);
+        if (fields.applyVisibilityToRelatedPosts && relatedPostIds.length) {
+            await this.propagateVisibilityToRelatedPosts(content.id, fields.status, manager, new Set([content.id]));
+        }
         await this.validatePermissionInheritance(manager);
         await this.replacePermissions(content.id, permissionIds, [], manager);
         await this.replaceApplicationHook(content.id, input.applicationHook ?? null, manager);
@@ -109,7 +237,21 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         return this.connection.transaction('SERIALIZABLE', async (manager) => {
             const current = await this.requireContent(id, manager);
             const snapshot = await this.snapshotOf(current, manager);
+            const visibility = await this.resolveVisibilityConfiguration(current, manager);
+            if (input.status !== undefined &&
+                visibility.source &&
+                input.status !== visibility.status) {
+                contentError('Visibility is inherited from a parent post and cannot be changed here.', 409);
+            }
             const fields = this.contentFields(input, snapshot);
+            if (visibility.source) {
+                fields.status = visibility.status;
+            }
+            if (input.status === 'published' &&
+                snapshot.status !== 'published' &&
+                input.publishedAt === undefined) {
+                fields.publishedAt = new Date();
+            }
             const tagIds = input.tagIds === undefined
                 ? snapshot.tagIds
                 : [...new Set(input.tagIds)];
@@ -125,6 +267,98 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
     async archiveContent(id: number, expectedVersion: number): Promise<TaonCmsContentEntity> {
         return this.updateContent(id, { status: 'archived', expectedVersion });
     }
+    async permanentlyDeleteContent(id: number, expectedVersion: number, deleteStorageObject: (key: string) => Promise<void>): Promise<void> {
+        requireContentId(id);
+        requireContentVersion(expectedVersion);
+        const assetKeys = await this.connection.transaction('SERIALIZABLE', async (manager) => {
+            const content = await this.requireContent(id, manager);
+            if (content.version !== expectedVersion) {
+                contentError('Content has changed. Reload it before editing.', 409);
+            }
+            if (content.status !== 'archived') {
+                contentError('Only archived posts can be permanently deleted.', 409);
+            }
+            const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+            const assetRepository = manager.getRepository<TaonCmsContentAssetEntity>(TaonCmsContentAssetEntity);
+            const assetKeys = [
+                content.videoKey,
+                content.audioKey,
+                content.attachmentKey,
+                content.thumbnailKey,
+            ].filter((key): key is string => !!key && !key.startsWith('cms-placeholder:'));
+            const unusedAssetKeys: string[] = [];
+            for (const key of new Set(assetKeys)) {
+                const references = await repository.find({
+                    where: [
+                        { videoKey: key },
+                        { audioKey: key },
+                        { attachmentKey: key },
+                        { thumbnailKey: key },
+                    ],
+                });
+                const assetReferences = await assetRepository.find({
+                    where: { key },
+                });
+                if (!references.some(reference => reference.id !== id) &&
+                    !assetReferences.some(asset => asset.contentId !== id)) {
+                    unusedAssetKeys.push(key);
+                }
+            }
+            if (content.relatedPosts?.length) {
+                await repository
+                    .createQueryBuilder()
+                    .relation('relatedPosts')
+                    .of(id)
+                    .remove(content.relatedPosts.map(post => post.id));
+            }
+            const parents = await repository.find({
+                where: { relatedPosts: { id } },
+            });
+            for (const parent of parents) {
+                await repository
+                    .createQueryBuilder()
+                    .relation('relatedPosts')
+                    .of(parent.id)
+                    .remove(id);
+            }
+            const versionPosts = await repository.find({
+                where: [{ publicVersionPostId: id }, { privateVersionPostId: id }],
+            });
+            for (const versionPost of versionPosts) {
+                if (versionPost.publicVersionPostId === id) {
+                    versionPost.publicVersionPostId = null;
+                }
+                if (versionPost.privateVersionPostId === id) {
+                    versionPost.privateVersionPostId = null;
+                }
+                versionPost.version += 1;
+                versionPost.updatedAt = new Date();
+                await repository.save(versionPost);
+            }
+            await this.taonCmsContentTagRepository.replaceTags(id, [], manager);
+            await this.replacePermissions(id, [], content.permissions.map(permission => permission.id), manager);
+            await this.replaceApplicationHook(id, null, manager);
+            await assetRepository.delete({ contentId: id });
+            await manager
+                .getRepository<TaonCmsContentRevisionEntity>(this.taonCmsContentRevisionRepository.target)
+                .delete({ contentId: id });
+            await repository.delete({ id });
+            return unusedAssetKeys;
+        });
+        const cleanupErrors: unknown[] = [];
+        for (const key of assetKeys) {
+            try {
+                await deleteStorageObject(key);
+            }
+            catch (error) {
+                cleanupErrors.push(error);
+            }
+        }
+        if (cleanupErrors.length) {
+            console.error('[taon-cms-content] Unable to clean up permanently deleted assets', cleanupErrors);
+            contentError('The post was deleted, but one or more asset files could not be removed.', 500);
+        }
+    }
     async restoreContent(id: number, input: TaonCmsRestoreContent): Promise<TaonCmsContentEntity> {
         requireContentId(id);
         if (!input || typeof input !== 'object') {
@@ -187,6 +421,63 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         requireContentId(id);
         return this.connection.transaction(async (manager) => (await this.requireContent(id, manager)).relatedPosts);
     }
+    async getParentPost(id: number): Promise<TaonCmsContentEntity | null> {
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => {
+            const parents = await manager
+                .getRepository<TaonCmsContentEntity>(this.target)
+                .find({
+                where: { relatedPosts: { id } },
+                order: { id: 'ASC' },
+            });
+            if (parents.length > 1) {
+                contentError('A post cannot have multiple parent posts.', 409);
+            }
+            return parents[0] ?? null;
+        });
+    }
+    async getPostVersions(id: number): Promise<TaonCmsPostVersionLinks> {
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => {
+            const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+            const post = await this.requireContent(id, manager);
+            const [publicVersionPost, privateVersionPost] = await Promise.all([
+                post.publicVersionPostId
+                    ? repository.findOneBy({ id: post.publicVersionPostId })
+                    : null,
+                post.privateVersionPostId
+                    ? repository.findOneBy({ id: post.privateVersionPostId })
+                    : null,
+            ]);
+            const validPublicVersion = Boolean(publicVersionPost &&
+                publicVersionPost.privateVersionPostId === post.id &&
+                publicVersionPost.publicVersionPostId === null);
+            const validPrivateVersion = Boolean(privateVersionPost &&
+                privateVersionPost.publicVersionPostId === post.id &&
+                privateVersionPost.privateVersionPostId === null);
+            let staleLinksRemoved = false;
+            if (post.publicVersionPostId && !validPublicVersion) {
+                post.publicVersionPostId = null;
+                staleLinksRemoved = true;
+            }
+            if (post.privateVersionPostId && !validPrivateVersion) {
+                post.privateVersionPostId = null;
+                staleLinksRemoved = true;
+            }
+            if (staleLinksRemoved) {
+                await repository.update(id, {
+                    publicVersionPostId: post.publicVersionPostId,
+                    privateVersionPostId: post.privateVersionPostId,
+                    version: post.version + 1,
+                    updatedAt: new Date(),
+                });
+            }
+            return {
+                publicVersionPost: validPublicVersion ? publicVersionPost : null,
+                privateVersionPost: validPrivateVersion ? privateVersionPost : null,
+            };
+        });
+    }
     async listPermissions(id: number): Promise<TaonPermissionEntity[]> {
         requireContentId(id);
         return (await this.getPermissionConfiguration(id)).permissions;
@@ -331,6 +622,141 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
     async deleteRelatedPost(id: number, relatedPostId: number, expectedVersion: number): Promise<TaonCmsContentEntity> {
         return this.changeRelatedPost(id, relatedPostId, expectedVersion, false);
     }
+    async linkVersionPost(id: number, versionPostId: number, kind: TaonCmsPostVersionKind, expectedVersion: number): Promise<TaonCmsContentEntity> {
+        requireContentId(id);
+        requireContentId(versionPostId, 'versionPostId');
+        requireContentVersion(expectedVersion);
+        if (kind !== 'public' && kind !== 'private') {
+            contentError('The post version kind is invalid.');
+        }
+        if (id === versionPostId) {
+            contentError('A post cannot be its own version.');
+        }
+        return this.connection.transaction('SERIALIZABLE', async (manager) => {
+            const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+            const post = await this.requireContent(id, manager);
+            const versionPost = await this.requireContent(versionPostId, manager);
+            if (post.version !== expectedVersion) {
+                contentError('Content has changed. Reload it before editing.', 409);
+            }
+            const versionStatusAllowed = kind === 'public'
+                ? versionPost.status === 'published' &&
+                    (post.status === 'draft' || post.status === 'archived')
+                : (versionPost.status === 'draft' ||
+                    versionPost.status === 'archived') &&
+                    post.status === 'published';
+            if (!versionStatusAllowed) {
+                contentError('The selected post is not eligible for this version link.');
+            }
+            const currentVersionId = kind === 'public'
+                ? post.publicVersionPostId
+                : post.privateVersionPostId;
+            const oppositeVersionId = kind === 'public'
+                ? post.privateVersionPostId
+                : post.publicVersionPostId;
+            const reciprocalVersionId = kind === 'public'
+                ? versionPost.privateVersionPostId
+                : versionPost.publicVersionPostId;
+            const oppositeReciprocalVersionId = kind === 'public'
+                ? versionPost.publicVersionPostId
+                : versionPost.privateVersionPostId;
+            if (oppositeVersionId !== null) {
+                contentError('This post is already linked to a different version.', 409);
+            }
+            if ((reciprocalVersionId !== null &&
+                reciprocalVersionId !== post.id) ||
+                oppositeReciprocalVersionId !== null) {
+                contentError('The selected post is already linked to another pair.', 409);
+            }
+            if (currentVersionId === versionPost.id) {
+                return post;
+            }
+            const currentVersion = currentVersionId
+                ? await repository.findOneBy({ id: currentVersionId })
+                : null;
+            if (currentVersion) {
+                const oldReciprocal = kind === 'public'
+                    ? currentVersion.privateVersionPostId
+                    : currentVersion.publicVersionPostId;
+                if (oldReciprocal !== post.id) {
+                    contentError('The existing post version link is conflicting.', 409);
+                }
+                await repository.update(currentVersion.id, {
+                    ...(kind === 'public'
+                        ? { privateVersionPostId: null }
+                        : { publicVersionPostId: null }),
+                    version: currentVersion.version + 1,
+                    updatedAt: new Date(),
+                });
+            }
+            const now = new Date();
+            await repository.update(post.id, {
+                ...(kind === 'public'
+                    ? { publicVersionPostId: versionPost.id }
+                    : { privateVersionPostId: versionPost.id }),
+                version: post.version + 1,
+                updatedAt: now,
+            });
+            await repository.update(versionPost.id, {
+                ...(kind === 'public'
+                    ? { privateVersionPostId: post.id }
+                    : { publicVersionPostId: post.id }),
+                version: versionPost.version + 1,
+                updatedAt: now,
+            });
+            return this.requireContent(post.id, manager);
+        });
+    }
+    async removeVersionPost(id: number, kind: TaonCmsPostVersionKind, expectedVersion: number): Promise<TaonCmsContentEntity> {
+        requireContentId(id);
+        requireContentVersion(expectedVersion);
+        if (kind !== 'public' && kind !== 'private') {
+            contentError('The post version kind is invalid.');
+        }
+        return this.connection.transaction('SERIALIZABLE', async (manager) => {
+            const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+            const post = await this.requireContent(id, manager);
+            if (post.version !== expectedVersion) {
+                contentError('Content has changed. Reload it before editing.', 409);
+            }
+            const canEditVersion = kind === 'public'
+                ? post.status === 'draft' || post.status === 'archived'
+                : post.status === 'published';
+            if (!canEditVersion) {
+                contentError('Version editing is disabled for the current post status.', 409);
+            }
+            const versionPostId = kind === 'public'
+                ? post.publicVersionPostId
+                : post.privateVersionPostId;
+            if (!versionPostId) {
+                return post;
+            }
+            const versionPost = await repository.findOneBy({ id: versionPostId });
+            if (versionPost) {
+                const reciprocalVersionId = kind === 'public'
+                    ? versionPost.privateVersionPostId
+                    : versionPost.publicVersionPostId;
+                if (reciprocalVersionId !== post.id) {
+                    contentError('The post version link is conflicting.', 409);
+                }
+                await repository.update(versionPost.id, {
+                    ...(kind === 'public'
+                        ? { privateVersionPostId: null }
+                        : { publicVersionPostId: null }),
+                    version: versionPost.version + 1,
+                    updatedAt: new Date(),
+                });
+            }
+            await repository.update(post.id, {
+                ...(kind === 'public'
+                    ? { publicVersionPostId: null }
+                    : { privateVersionPostId: null }),
+                version: post.version + 1,
+                updatedAt: new Date(),
+            });
+            return this.requireContent(post.id, manager);
+        });
+    }
     private async changeRelatedPost(id: number, relatedPostId: number, expectedVersion: number, adding: boolean): Promise<TaonCmsContentEntity> {
         requireContentId(id);
         requireContentId(relatedPostId, 'relatedPostId');
@@ -406,6 +832,9 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
             applyPermissionsToRelatedPosts: input.applyPermissionsToRelatedPosts ??
                 current?.applyPermissionsToRelatedPosts ??
                 false,
+            applyVisibilityToRelatedPosts: input.applyVisibilityToRelatedPosts ??
+                current?.applyVisibilityToRelatedPosts ??
+                false,
         };
     }
     private async snapshotOf(content: TaonCmsContentEntity, manager: EntityManager): Promise<TaonCmsContentSnapshot> {
@@ -468,6 +897,18 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         }
         const added = relatedPostIds.filter(postId => !previousIds.includes(postId));
         const removed = previousIds.filter(postId => !relatedPostIds.includes(postId));
+        for (const relatedPostId of added) {
+            const parents = await repository.find({
+                where: { relatedPosts: { id: relatedPostId } },
+                select: { id: true },
+            });
+            if (parents.some(parent => parent.id !== id)) {
+                contentError('A post cannot have multiple parent posts.', 409);
+            }
+            if (await this.relatedPostPathExists(relatedPostId, id, manager)) {
+                contentError('Related posts cannot contain circular relationships.', 409);
+            }
+        }
         if (added.length || removed.length) {
             await repository
                 .createQueryBuilder()
@@ -476,6 +917,30 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
                 .addAndRemove(added, removed);
         }
     }
+    private async relatedPostPathExists(startId: number, targetId: number, manager: EntityManager): Promise<boolean> {
+        const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+        const pending = [startId];
+        const visited = new Set<number>();
+        while (pending.length) {
+            const currentId = pending.pop();
+            if (currentId === undefined) {
+                continue;
+            }
+            if (currentId === targetId) {
+                return true;
+            }
+            if (visited.has(currentId)) {
+                continue;
+            }
+            visited.add(currentId);
+            const current = await repository.findOne({
+                where: { id: currentId },
+                relations: { relatedPosts: true },
+            });
+            pending.push(...(current?.relatedPosts ?? []).map(post => post.id));
+        }
+        return false;
+    }
     private async replacePermissions(id: number, permissionIds: number[], previousIds: number[], manager: EntityManager): Promise<void> {
         const added = permissionIds.filter(permissionId => !previousIds.includes(permissionId));
         const removed = previousIds.filter(permissionId => !permissionIds.includes(permissionId));
@@ -515,7 +980,7 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
         target.contentId = contentId;
         await repository.save(target);
     }
-    private async commitUpdate(current: TaonCmsContentEntity, expectedVersion: number, snapshot: TaonCmsContentSnapshot, manager: EntityManager, applicationHook?: TaonCmsApplicationHook | null): Promise<TaonCmsContentEntity> {
+    private async commitUpdate(current: TaonCmsContentEntity, expectedVersion: number, snapshot: TaonCmsContentSnapshot, manager: EntityManager, applicationHook?: TaonCmsApplicationHook | null, propagateVisibility = true): Promise<TaonCmsContentEntity> {
         if (current.version !== expectedVersion) {
             contentError('Content has changed. Reload it before editing.', 409);
         }
@@ -546,8 +1011,34 @@ export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentE
             relatedPostIds: updated.relatedPosts.map(post => post.id),
             permissionIds: updated.permissions.map(permission => permission.id),
         }, manager);
+        if (propagateVisibility) {
+            const visibility = await this.resolveVisibilityConfiguration(updated, manager);
+            if (snapshot.applyVisibilityToRelatedPosts || visibility.source) {
+                await this.propagateVisibilityToRelatedPosts(updated.id, snapshot.status, manager, new Set([updated.id]));
+            }
+        }
         return updated;
     }
+    private async propagateVisibilityToRelatedPosts(parentId: number, status: TaonCmsContentFields['status'], manager: EntityManager, visited: Set<number>): Promise<void> {
+        const parent = await this.requireContent(parentId, manager);
+        for (const relatedPost of parent.relatedPosts ?? []) {
+            if (visited.has(relatedPost.id)) {
+                contentError('Related posts cannot contain circular relationships.', 409);
+            }
+            visited.add(relatedPost.id);
+            const child = await this.requireContent(relatedPost.id, manager);
+            if (child.status !== status) {
+                const snapshot = await this.snapshotOf(child, manager);
+                const previousStatus = snapshot.status;
+                snapshot.status = status;
+                if (status === 'published' && previousStatus !== 'published') {
+                    snapshot.publishedAt = new Date();
+                }
+                await this.commitUpdate(child, child.version, snapshot, manager, undefined, false);
+            }
+            await this.propagateVisibilityToRelatedPosts(child.id, status, manager, visited);
+        }
+    }
     async countEntitesWithEvenId(): Promise<number> {
         const result = await this.count({
             where: {

package/ts-source/websql-code-prod/taon-cms-content/taon-cms-content.validation.ts

@@ -69,6 +69,10 @@ export function validateContentInput(input: Partial<TaonCmsContentFields> & {
         typeof input.applyPermissionsToRelatedPosts !== 'boolean') {
         contentError('applyPermissionsToRelatedPosts must be a boolean.');
     }
+    if (input.applyVisibilityToRelatedPosts !== undefined &&
+        typeof input.applyVisibilityToRelatedPosts !== 'boolean') {
+        contentError('applyVisibilityToRelatedPosts must be a boolean.');
+    }
     if (input.status !== undefined &&
         !['draft', 'published', 'archived'].includes(input.status)) {
         contentError('status must be draft, published, or archived.');