@taon-dev/cms 21.0.23 → 21.0.25

package/lib-esm/lib/taon-cms-content/taon-cms-content.repository.js

@@ -7,8 +7,11 @@ import { TaonCmsCategoryRepository } from '../taon-cms-category/taon-cms-categor
 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 { _ } from 'tnp-core/lib-esm';
 import { TaonCmsContentEntity } from './taon-cms-content.entity';
 import { TaonCmsContentType } from './taon-cms-content.models';
+import { TaonCmsContentUtils } from './taon-cms-content.utils';
 import { contentError, requireContentId, requireContentVersion, validateContentInput, } from './taon-cms-content.validation';
 //#endregion
 let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRepository {
@@ -26,52 +29,428 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         });
         //#endregion
     }
+    async getVisibilityConfiguration(id) {
+        //#region @websqlFunc
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => {
+            const content = await this.requireContent(id, manager);
+            return this.resolveVisibilityConfiguration(content, manager);
+        });
+        //#endregion
+    }
     async createContent(input) {
         //#region @websqlFunc
         validateContentInput(input, true);
         return this.connection.transaction('SERIALIZABLE', manager => this.createContentWithManager(input, manager));
         //#endregion
     }
-    async duplicateContent(id) {
+    async createRelatedChild(parentId, input) {
         //#region @websqlFunc
-        requireContentId(id);
+        requireContentId(parentId, 'parentId');
+        this.validateRelatedChildInput(input);
         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 parent = await this.requireContent(parentId, manager);
+            const prefix = input.titlePrefix.trim();
+            const requestedTitle = input.expectedTitle.trim();
+            const matchingChild = parent.relatedPosts.find(child => child.title === requestedTitle &&
+                this.relatedChildMatchesInput(child, input));
+            if (matchingChild) {
+                return { child: matchingChild, parentVersion: parent.version };
+            }
+            const uploadedKeys = [
+                input.sourceKey,
+                ...(input.thumbnailKey.startsWith('cms-placeholder:')
+                    ? []
+                    : [input.thumbnailKey]),
+            ];
+            for (const key of new Set(uploadedKeys)) {
+                if (await this.isMediaKeyInUseWithinManager(key, manager)) {
+                    contentError('An uploaded media file is already assigned to a post.', 409);
+                }
+            }
+            const title = this.nextRelatedChildTitle(prefix, parent.relatedPosts);
+            if (requestedTitle !== title) {
+                contentError('The child title sequence changed. Reload related posts and retry.', 409);
+            }
+            const inheritedVisibility = await this.resolveVisibilityConfiguration(parent, manager);
+            const status = parent.applyVisibilityToRelatedPosts
+                ? this.contentStatus(parent.status)
+                : inheritedVisibility.source
+                    ? inheritedVisibility.status
+                    : 'draft';
             const repository = manager.getRepository(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 baseSlug = _.kebabCase(title);
+            if (!baseSlug) {
+                contentError('The child title cannot be converted into a URL slug.');
+            }
+            let slug = baseSlug;
+            let suffix = 2;
+            while (await repository.findOneBy({ slug })) {
+                slug = `${baseSlug}-${suffix}`;
+                suffix += 1;
+            }
+            const child = await this.createContentWithManager({
+                title,
+                slug,
+                type: input.type,
+                body: input.body,
+                videoKey: input.videoKey,
+                audioKey: input.audioKey,
+                attachmentKey: input.attachmentKey,
+                thumbnailKey: input.thumbnailKey,
+                status,
+                publishedAt: status === 'published' ? new Date() : null,
+                relatedPostIds: [],
+                tagIds: [],
+                permissionIds: [],
+                applicationHook: null,
+            }, manager);
+            const snapshot = await this.snapshotOf(parent, manager);
+            snapshot.relatedPostIds = [
+                ...parent.relatedPosts.map(relatedPost => relatedPost.id),
+                child.id,
+            ];
+            const updatedParent = await this.commitUpdate(parent, parent.version, snapshot, manager, undefined, false);
+            return { child, parentVersion: updatedParent.version };
+        });
+        //#endregion
+    }
+    validateRelatedChildInput(input) {
+        //#region @websqlFunc
+        if (!input || typeof input !== 'object') {
+            contentError('The child post input is invalid.');
+        }
+        const prefix = typeof input.titlePrefix === 'string' ? input.titlePrefix.trim() : '';
+        if (!prefix || prefix.length > 240 || /[\r\n]/.test(prefix)) {
+            contentError('The child title prefix is invalid.');
+        }
+        if (typeof input.expectedTitle !== 'string' ||
+            !input.expectedTitle.trim() ||
+            input.expectedTitle.trim().length > 255) {
+            contentError('The child title is invalid.');
+        }
+        if (typeof input.fileName !== 'string' ||
+            !input.fileName.trim() ||
+            input.fileName.length > 255 ||
+            typeof input.mimeType !== 'string' ||
+            input.mimeType.length > 127) {
+            contentError('The uploaded file information is invalid.');
+        }
+        if ((input.body !== null && typeof input.body !== 'string') ||
+            (typeof input.body === 'string' && input.body.length > 10_000_000)) {
+            contentError('The document content is invalid or too large.');
+        }
+        for (const key of [
+            input.videoKey,
+            input.audioKey,
+            input.attachmentKey,
+        ]) {
+            if (key !== null && typeof key !== 'string') {
+                contentError('The uploaded media key is invalid.');
+            }
+        }
+        if (typeof input.sourceKey !== 'string' ||
+            !input.sourceKey.trim() ||
+            input.sourceKey.length > 1024 ||
+            typeof input.thumbnailKey !== 'string' ||
+            !input.thumbnailKey.trim() ||
+            input.thumbnailKey.length > 1024) {
+            contentError('The uploaded media key is invalid.');
+        }
+        const fileName = input.fileName.split(/[\\/]/).pop() ?? '';
+        const keyFileName = input.sourceKey.split('/').pop() ?? '';
+        const storedFileName = keyFileName.replace(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}__/i, '');
+        if (storedFileName === keyFileName) {
+            contentError('The uploaded source media key is invalid.');
+        }
+        const extension = fileName.match(/\.([^.]+)$/)?.[1]?.toLowerCase() ?? '';
+        const keyExtension = storedFileName.match(/\.([^.]+)$/)?.[1]?.toLowerCase() ?? '';
+        if (extension !== keyExtension) {
+            contentError('The uploaded file extension does not match its media key.');
+        }
+        const documentExtensions = new Set(['doc', 'docx', 'rtf', 'txt']);
+        const videoExtensions = new Set([
+            '3gp',
+            'avi',
+            'm4v',
+            'mkv',
+            'mov',
+            'mp4',
+            'mpeg',
+            'mpg',
+            'ogv',
+            'webm',
+        ]);
+        const audioExtensions = new Set([
+            'aac',
+            'flac',
+            'm4a',
+            'mp3',
+            'oga',
+            'ogg',
+            'opus',
+            'wav',
+            'weba',
+            'wma',
+        ]);
+        const mimeType = input.mimeType.toLowerCase();
+        const expectedType = documentExtensions.has(extension)
+            ? TaonCmsContentType.Normal
+            : mimeType.startsWith('video/')
+                ? TaonCmsContentType.Video
+                : mimeType.startsWith('audio/')
+                    ? TaonCmsContentType.Audio
+                    : videoExtensions.has(extension)
+                        ? TaonCmsContentType.Video
+                        : audioExtensions.has(extension)
+                            ? TaonCmsContentType.Audio
+                            : TaonCmsContentType.Attachment;
+        if (input.type !== expectedType) {
+            contentError('The uploaded file type does not match the child post type.');
+        }
+        if (input.type === TaonCmsContentType.Video) {
+            if (input.videoKey !== input.sourceKey ||
+                input.audioKey !== null ||
+                input.attachmentKey !== null ||
+                input.body !== null ||
+                input.thumbnailKey === 'cms-placeholder:video') {
+                contentError('The video child media mapping is invalid.');
+            }
+            if (!/\.(?:avif|gif|jpe?g|png|webp)$/i.test(input.thumbnailKey)) {
+                contentError('The video thumbnail file type is invalid.');
+            }
+        }
+        else if (input.type === TaonCmsContentType.Audio) {
+            if (input.audioKey !== input.sourceKey ||
+                input.videoKey !== null ||
+                input.attachmentKey !== null ||
+                input.body !== null ||
+                input.thumbnailKey !== 'cms-placeholder:audio') {
+                contentError('The audio child media mapping is invalid.');
+            }
+        }
+        else if (input.type === TaonCmsContentType.Normal) {
+            if (!input.body?.trim() ||
+                input.videoKey !== null ||
+                input.audioKey !== null ||
+                input.attachmentKey !== null ||
+                input.thumbnailKey !== 'cms-placeholder:normal') {
+                contentError('The document child content mapping is invalid.');
+            }
+        }
+        else if (input.attachmentKey !== input.sourceKey ||
+            input.videoKey !== null ||
+            input.audioKey !== null ||
+            input.body !== null ||
+            input.thumbnailKey !== 'cms-placeholder:normal') {
+            contentError('The attachment child media mapping is invalid.');
+        }
+        //#endregion
+    }
+    relatedChildMatchesInput(child, input) {
+        //#region @websqlFunc
+        return (child.type === input.type &&
+            child.body === input.body &&
+            child.videoKey === input.videoKey &&
+            child.audioKey === input.audioKey &&
+            child.attachmentKey === input.attachmentKey &&
+            child.thumbnailKey === input.thumbnailKey);
+        //#endregion
+    }
+    nextRelatedChildTitle(prefix, children) {
+        //#region @websqlFunc
+        let highest = 0;
+        for (const child of children) {
+            const candidatePrefix = `${prefix} `;
+            if (!child.title.startsWith(candidatePrefix)) {
+                continue;
+            }
+            const suffix = child.title.slice(candidatePrefix.length);
+            if (!/^\d+$/.test(suffix)) {
+                continue;
+            }
+            const number = Number(suffix);
+            if (Number.isSafeInteger(number)) {
+                highest = Math.max(highest, number);
+            }
+        }
+        const next = highest + 1;
+        if (!Number.isSafeInteger(next)) {
+            contentError('No available child title number could be generated.', 409);
+        }
+        return `${prefix} ${String(next).padStart(2, '0')}`;
+        //#endregion
+    }
+    async isMediaKeyInUseWithinManager(key, manager) {
+        //#region @websqlFunc
+        return !!(await manager
+            .getRepository(this.target)
+            .findOne({
+            where: [
+                { videoKey: key },
+                { audioKey: key },
+                { attachmentKey: key },
+                { thumbnailKey: key },
+            ],
+            select: { id: true },
+        }));
+        //#endregion
+    }
+    async resolveVisibilityConfiguration(post, manager) {
+        //#region @websqlFunc
+        const repository = manager.getRepository(this.target);
+        let childId = post.id;
+        const visited = new Set([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;
+        }
+        //#endregion
+    }
+    async duplicateContent(id, includeChildren, copyStorageObject, deleteStorageObject) {
+        //#region @websqlFunc
+        requireContentId(id);
+        const copiedKeys = [];
+        try {
+            return await this.connection.transaction('SERIALIZABLE', async (manager) => {
+                const processed = new Set();
+                const duplicateNode = async (source, inheritedStatus) => {
+                    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 = [];
+                    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();
+                    for (const field of [
+                        'videoKey',
+                        'audioKey',
+                        'attachmentKey',
+                        'thumbnailKey',
+                    ]) {
+                        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,
-                        // Inherited permissions become independent without related links.
                         permissionIds: configuration.permissions.map(permission => permission.id),
                     }, manager);
+                    const assetRepository = manager.getRepository(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 = [];
+            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;
+        }
         //#endregion
     }
+    async nextCopyTitleAndSlug(title, slug, manager) {
+        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(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);
+    }
     async createContentWithManager(input, manager) {
         //#region @websqlFunc
         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 ?? [])];
@@ -87,10 +466,13 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         }));
         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);
-        await this.taonCmsContentRevisionRepository.recordContent(content, { ...fields, tagIds, relatedPostIds, permissionIds }, manager);
+        await this.taonCmsContentRevisionRepository.recordContent(content, { ...fields, tagIds, relatedPostIds, relatedPostOrderSaved: true, permissionIds }, manager);
         return this.requireContent(content.id, manager);
         //#endregion
     }
@@ -102,7 +484,21 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         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)];
@@ -121,6 +517,100 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         return this.updateContent(id, { status: 'archived', expectedVersion });
         //#endregion
     }
+    async permanentlyDeleteContent(id, expectedVersion, deleteStorageObject) {
+        //#region @websqlFunc
+        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(this.target);
+            const assetRepository = manager.getRepository(TaonCmsContentAssetEntity);
+            const assetKeys = [
+                content.videoKey,
+                content.audioKey,
+                content.attachmentKey,
+                content.thumbnailKey,
+            ].filter((key) => !!key && !key.startsWith('cms-placeholder:'));
+            const unusedAssetKeys = [];
+            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(this.taonCmsContentRevisionRepository.target)
+                .delete({ contentId: id });
+            await repository.delete({ id });
+            return unusedAssetKeys;
+        });
+        const cleanupErrors = [];
+        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);
+        }
+        //#endregion
+    }
     async restoreContent(id, input) {
         //#region @websqlFunc
         requireContentId(id);
@@ -192,6 +682,88 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         return this.connection.transaction(async (manager) => (await this.requireContent(id, manager)).relatedPosts);
         //#endregion
     }
+    async listPublicVideoChildren(parentId) {
+        //#region @websqlFunc
+        requireContentId(parentId, 'parentId');
+        return this.connection.transaction(async (manager) => {
+            const parent = await this.requireContent(parentId, manager);
+            const publicChildren = [];
+            for (const child of parent.relatedPosts) {
+                if (child.type !== TaonCmsContentType.Video ||
+                    child.status !== 'published' ||
+                    !child.videoKey) {
+                    continue;
+                }
+                const permissions = await this.resolvePermissionConfiguration(child, manager);
+                if (!permissions.permissions?.length) {
+                    publicChildren.push(child);
+                }
+            }
+            return publicChildren;
+        });
+        //#endregion
+    }
+    async getParentPost(id) {
+        //#region @websqlFunc
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => {
+            const parents = await manager
+                .getRepository(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;
+        });
+        //#endregion
+    }
+    async getPostVersions(id) {
+        //#region @websqlFunc
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => {
+            const repository = manager.getRepository(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,
+            };
+        });
+        //#endregion
+    }
     async listPermissions(id) {
         //#region @websqlFunc
         requireContentId(id);
@@ -352,6 +924,21 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         //#endregion
     }
     //#endregion
+    async isMediaKeyInUse(key) {
+        //#region @websqlFunc
+        return !!(await this.connection
+            .getRepository(this.target)
+            .findOne({
+            where: [
+                { videoKey: key },
+                { audioKey: key },
+                { attachmentKey: key },
+                { thumbnailKey: key },
+            ],
+            select: { id: true },
+        }));
+        //#endregion
+    }
     async addRelatedPost(id, relatedPostId, expectedVersion) {
         //#region @websqlFunc
         return this.changeRelatedPost(id, relatedPostId, expectedVersion, true);
@@ -362,6 +949,145 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         return this.changeRelatedPost(id, relatedPostId, expectedVersion, false);
         //#endregion
     }
+    async linkVersionPost(id, versionPostId, kind, expectedVersion) {
+        //#region @websqlFunc
+        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(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);
+        });
+        //#endregion
+    }
+    async removeVersionPost(id, kind, expectedVersion) {
+        //#region @websqlFunc
+        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(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);
+        });
+        //#endregion
+    }
     async changeRelatedPost(id, relatedPostId, expectedVersion, adding) {
         //#region @websqlFunc
         requireContentId(id);
@@ -397,6 +1123,7 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         if (!content) {
             contentError(`Content ${id} does not exist.`, 404);
         }
+        await this.taonCmsContentRevisionRepository.applyRelatedPostOrder(content, manager);
         return content;
         //#endregion
     }
@@ -441,6 +1168,9 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
             applyPermissionsToRelatedPosts: input.applyPermissionsToRelatedPosts ??
                 current?.applyPermissionsToRelatedPosts ??
                 false,
+            applyVisibilityToRelatedPosts: input.applyVisibilityToRelatedPosts ??
+                current?.applyVisibilityToRelatedPosts ??
+                false,
         };
     }
     async snapshotOf(content, manager) {
@@ -512,6 +1242,18 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         }
         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()
@@ -521,6 +1263,32 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         }
         //#endregion
     }
+    async relatedPostPathExists(startId, targetId, manager) {
+        //#region @websqlFunc
+        const repository = manager.getRepository(this.target);
+        const pending = [startId];
+        const visited = new Set();
+        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;
+        //#endregion
+    }
     async replacePermissions(id, permissionIds, previousIds, manager) {
         //#region @websqlFunc
         const added = permissionIds.filter(permissionId => !previousIds.includes(permissionId));
@@ -564,7 +1332,7 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
         await repository.save(target);
         //#endregion
     }
-    async commitUpdate(current, expectedVersion, snapshot, manager, applicationHook) {
+    async commitUpdate(current, expectedVersion, snapshot, manager, applicationHook, propagateVisibility = true) {
         //#region @websqlFunc
         if (current.version !== expectedVersion) {
             contentError('Content has changed. Reload it before editing.', 409);
@@ -591,15 +1359,47 @@ let TaonCmsContentRepository = class TaonCmsContentRepository extends TaonBaseRe
             await this.replaceApplicationHook(current.id, applicationHook, manager);
         }
         const updated = await this.requireContent(current.id, manager);
+        // The join table has no order; the revision snapshot is the saved sequence.
+        const relatedPostIds = [...new Set(snapshot.relatedPostIds ?? [])];
+        TaonCmsContentUtils.orderRelatedPosts(updated.relatedPosts, relatedPostIds);
         await this.taonCmsContentRevisionRepository.recordContent(updated, {
             ...fields,
             tagIds: snapshot.tagIds,
-            relatedPostIds: updated.relatedPosts.map(post => post.id),
+            relatedPostIds,
+            relatedPostOrderSaved: true,
             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;
         //#endregion
     }
+    async propagateVisibilityToRelatedPosts(parentId, status, manager, visited) {
+        //#region @websqlFunc
+        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);
+        }
+        //#endregion
+    }
     /**
      * TODO remove this demo example method
      */