@taon-dev/cms 21.0.13 → 21.0.16

package/ts-source/websql-code/taon-cms-content/taon-cms-content.entity.ts

@@ -0,0 +1,72 @@
+// @ts-nocheck
+/* ============================================================================
+
+- TAON READONLY SOURCE
+- DO NOT MODIFY THIS FILE.
+- Changes may be overwritten.
+- Use command: taon build:watch:lib
+  inside @taon-dev/cms project repository
+  for watch development of third party modules like this.
+  
+ * ========================================================================== */
+
+import { Column, JoinTable, ManyToMany, OneToOne, CustomColumn, PrimaryGeneratedColumn, Taon, TaonBaseAbstractEntity, TaonBaseEntity, TaonEntity, } from 'taon/websql';
+import { _ } from 'tnp-core/websql';
+import { TaonPermissionEntity } from '@taon-dev/session/websql';
+import { TaonCmsApplicationHookEntity } from '../taon-cms-application-hook/taon-cms-application-hook.entity';
+import { TaonCmsContentDefaultsValues } from './taon-cms-content.constants';
+import { TaonCmsContentType } from './taon-cms-content.models';
+@TaonEntity({
+    className: 'TaonCmsContentEntity',
+    createTable: true,
+})
+export class TaonCmsContentEntity extends TaonBaseEntity<TaonCmsContentEntity> {
+    @PrimaryGeneratedColumn()
+    id: number;
+    @Column({ type: 'integer', default: 0 })
+    version: number;
+    @Column({ type: 'varchar', default: TaonCmsContentType.Normal })
+    type: TaonCmsContentType = TaonCmsContentType.Normal;
+    @Column({ type: 'varchar' })
+    title: string;
+    @Column({ type: 'varchar', unique: true })
+    slug: string;
+    @ManyToMany(() => TaonCmsContentEntity)
+    @JoinTable({
+        name: 'taon_cms_related_posts',
+        joinColumn: { name: 'contentId', referencedColumnName: 'id' },
+        inverseJoinColumn: { name: 'relatedPostId', referencedColumnName: 'id' },
+    })
+    relatedPosts: TaonCmsContentEntity[];
+    @OneToOne(() => TaonCmsApplicationHookEntity, applicationHook => applicationHook.content)
+    applicationHook: TaonCmsApplicationHookEntity | null;
+    @ManyToMany(() => TaonPermissionEntity)
+    @JoinTable({
+        name: 'taon_cms_content_permissions',
+        joinColumn: { name: 'contentId', referencedColumnName: 'id' },
+        inverseJoinColumn: { name: 'permissionId', referencedColumnName: 'id' },
+    })
+    permissions: TaonPermissionEntity[];
+    @Column({ type: 'text', nullable: true })
+    excerpt: string | null;
+    @Column({ type: 'text', nullable: true })
+    body: string | null;
+    @Column({ type: 'varchar', nullable: true })
+    videoKey: string | null = null;
+    @Column({ type: 'varchar', nullable: true })
+    audioKey: string | null = null;
+    @Column({ type: 'varchar', nullable: true })
+    attachmentKey: string | null = null;
+    @Column({ type: 'integer', nullable: true })
+    categoryId: number | null;
+    @Column({ type: 'integer', nullable: true })
+    authorUserId: number | null;
+    @Column({ type: 'varchar', default: 'draft' })
+    status: string;
+    @Column({ type: 'datetime', nullable: true })
+    publishedAt: Date | null;
+    @Column({ type: 'datetime' })
+    createdAt: Date;
+    @Column({ type: 'datetime' })
+    updatedAt: Date;
+}

package/ts-source/websql-code/taon-cms-content/taon-cms-content.middleware.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+/* ============================================================================
+
+- TAON READONLY SOURCE
+- DO NOT MODIFY THIS FILE.
+- Changes may be overwritten.
+- Use command: taon build:watch:lib
+  inside @taon-dev/cms project repository
+  for watch development of third party modules like this.
+  
+ * ========================================================================== */
+
+import { Taon, TaonBaseMiddleware, TaonMiddleware } from 'taon/websql';
+import { _ } from 'tnp-core/websql';
+@TaonMiddleware({
+    className: 'TaonCmsContentMiddleware',
+})
+export class TaonCmsContentMiddleware extends TaonBaseMiddleware {
+}

package/ts-source/websql-code/taon-cms-content/taon-cms-content.models.ts

@@ -0,0 +1,59 @@
+// @ts-nocheck
+/* ============================================================================
+
+- TAON READONLY SOURCE
+- DO NOT MODIFY THIS FILE.
+- Changes may be overwritten.
+- Use command: taon build:watch:lib
+  inside @taon-dev/cms project repository
+  for watch development of third party modules like this.
+  
+ * ========================================================================== */
+
+export enum TaonCmsContentType {
+    Normal = 'normal',
+    Video = 'video',
+    Audio = 'audio',
+    Attachment = 'attachment'
+}
+export enum TaonCmsContentState {
+    Active = 'active',
+    Inactive = 'inactive'
+}
+export interface TaonCmsContentFields {
+    type: TaonCmsContentType;
+    title: string;
+    slug: string;
+    body: string | null;
+    videoKey: string | null;
+    audioKey: string | null;
+    attachmentKey: string | null;
+    excerpt: string | null;
+    categoryId: number | null;
+    authorUserId: number | null;
+    status: 'draft' | 'published' | 'archived';
+    publishedAt: Date | null;
+}
+export interface TaonCmsCreateContent extends Pick<TaonCmsContentFields, 'title' | 'slug'>, Partial<Omit<TaonCmsContentFields, 'title' | 'slug'>> {
+    tagIds?: number[];
+    relatedPostIds?: number[];
+    permissionIds?: number[];
+    applicationHook?: TaonCmsApplicationHook | null;
+}
+export interface TaonCmsUpdateContent extends Partial<TaonCmsContentFields> {
+    tagIds?: number[];
+    relatedPostIds?: number[];
+    permissionIds?: number[];
+    applicationHook?: TaonCmsApplicationHook | null;
+    expectedVersion: number;
+}
+export interface TaonCmsRestoreContent {
+    revisionNumber: number;
+    expectedVersion: number;
+}
+export interface TaonCmsContentSnapshot extends TaonCmsContentFields {
+    tagIds: number[];
+    relatedPostIds?: number[];
+    permissionIds: number[];
+}
+import type { TaonCmsApplicationHook } from '../taon-cms-application-hooks';

package/ts-source/websql-code/taon-cms-content/taon-cms-content.provider.ts

@@ -0,0 +1,21 @@
+// @ts-nocheck
+/* ============================================================================
+
+- TAON READONLY SOURCE
+- DO NOT MODIFY THIS FILE.
+- Changes may be overwritten.
+- Use command: taon build:watch:lib
+  inside @taon-dev/cms project repository
+  for watch development of third party modules like this.
+  
+ * ========================================================================== */
+
+import { Taon, TaonBaseProvider, TaonProvider } from 'taon/websql';
+import { _ } from 'tnp-core/websql';
+import { Injectable } from '@angular/core';
+@TaonProvider({
+    className: 'TaonCmsContentProvider',
+})
+@Injectable()
+export class TaonCmsContentProvider extends TaonBaseProvider {
+}

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

@@ -0,0 +1,374 @@
+// @ts-nocheck
+/* ============================================================================
+
+- TAON READONLY SOURCE
+- DO NOT MODIFY THIS FILE.
+- Changes may be overwritten.
+- Use command: taon build:watch:lib
+  inside @taon-dev/cms project repository
+  for watch development of third party modules like this.
+  
+ * ========================================================================== */
+
+import { TaonBaseRepository, TaonRepository } from 'taon/websql';
+import { In, Raw } from 'taon-typeorm/websql';
+import type { EntityManager } from 'taon-typeorm/websql';
+import { TaonPermissionEntity } from '@taon-dev/session/websql';
+import { TaonCmsApplicationHookEntity } from '../taon-cms-application-hook/taon-cms-application-hook.entity';
+import type { TaonCmsApplicationHook } from '../taon-cms-application-hooks';
+import { TaonCmsCategoryRepository } from '../taon-cms-category/taon-cms-category.repository';
+import type { TaonCmsContentRevisionEntity } from '../taon-cms-content-revision/taon-cms-content-revision.entity';
+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 { TaonCmsContentEntity } from './taon-cms-content.entity';
+import { TaonCmsContentType } from './taon-cms-content.models';
+import type { TaonCmsContentFields, TaonCmsContentSnapshot, TaonCmsCreateContent, TaonCmsRestoreContent, TaonCmsUpdateContent, } from './taon-cms-content.models';
+import { contentError, requireContentId, requireContentVersion, validateContentInput, } from './taon-cms-content.validation';
+@TaonRepository({
+    className: 'TaonCmsContentRepository',
+})
+export class TaonCmsContentRepository extends TaonBaseRepository<TaonCmsContentEntity> {
+    entityClassResolveFn: () => typeof TaonCmsContentEntity = () => TaonCmsContentEntity;
+    private readonly taonCmsContentRevisionRepository = this.injectCustomRepo(TaonCmsContentRevisionRepository);
+    private readonly taonCmsContentTagRepository = this.injectCustomRepo(TaonCmsContentTagRepository);
+    private readonly taonCmsCategoryRepository = this.injectCustomRepo(TaonCmsCategoryRepository);
+    private readonly tags = this.injectCustomRepo(TaonCmsTagRepository);
+    async createContent(input: TaonCmsCreateContent): Promise<TaonCmsContentEntity> {
+        validateContentInput(input, true);
+        return this.connection.transaction(async (manager) => {
+            const fields = this.contentFields(input);
+            const tagIds = [...new Set(input.tagIds ?? [])];
+            const relatedPostIds = [...new Set(input.relatedPostIds ?? [])];
+            const permissionIds = [...new Set(input.permissionIds ?? [])];
+            await this.validateReferences(fields, tagIds, permissionIds, manager);
+            await this.requireAvailableSlug(fields.slug, manager);
+            const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+            const now = new Date();
+            const content = await repository.save(repository.create({
+                ...fields,
+                version: 1,
+                createdAt: now,
+                updatedAt: now,
+            }));
+            await this.taonCmsContentTagRepository.replaceTags(content.id, tagIds, manager);
+            await this.replaceRelatedPosts(content.id, relatedPostIds, [], 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);
+            return this.requireContent(content.id, manager);
+        });
+    }
+    async updateContent(id: number, input: TaonCmsUpdateContent): Promise<TaonCmsContentEntity> {
+        requireContentId(id);
+        validateContentInput(input);
+        requireContentVersion(input.expectedVersion);
+        return this.connection.transaction(async (manager) => {
+            const current = await this.requireContent(id, manager);
+            const snapshot = await this.snapshotOf(current, manager);
+            const fields = this.contentFields(input, snapshot);
+            const tagIds = input.tagIds === undefined
+                ? snapshot.tagIds
+                : [...new Set(input.tagIds)];
+            const relatedPostIds = input.relatedPostIds === undefined
+                ? snapshot.relatedPostIds
+                : [...new Set(input.relatedPostIds)];
+            const permissionIds = input.permissionIds === undefined
+                ? snapshot.permissionIds
+                : [...new Set(input.permissionIds)];
+            return this.commitUpdate(current, input.expectedVersion, { ...fields, tagIds, relatedPostIds, permissionIds }, manager, input.applicationHook);
+        });
+    }
+    async archiveContent(id: number, expectedVersion: number): Promise<TaonCmsContentEntity> {
+        return this.updateContent(id, { status: 'archived', expectedVersion });
+    }
+    async restoreContent(id: number, input: TaonCmsRestoreContent): Promise<TaonCmsContentEntity> {
+        requireContentId(id);
+        if (!input || typeof input !== 'object') {
+            contentError('Restore input must be an object.');
+        }
+        requireContentVersion(input.revisionNumber, 'revisionNumber');
+        requireContentVersion(input.expectedVersion);
+        return this.connection.transaction(async (manager) => {
+            const current = await this.requireContent(id, manager);
+            const revision = await this.taonCmsContentRevisionRepository.requireRevision(id, input.revisionNumber, manager);
+            if (!revision.snapshot) {
+                contentError('This legacy revision has no complete snapshot and cannot be restored.', 409);
+            }
+            const storedSnapshot = revision.snapshot;
+            const snapshotFields: (keyof TaonCmsContentSnapshot)[] = [
+                'type',
+                'title',
+                'slug',
+                'body',
+                'excerpt',
+                'categoryId',
+                'authorUserId',
+                'status',
+                'publishedAt',
+                'tagIds',
+            ];
+            if (snapshotFields.some(field => storedSnapshot[field] === undefined)) {
+                contentError('This revision has an incomplete snapshot and cannot be restored.', 409);
+            }
+            validateContentInput(revision.snapshot, true);
+            const snapshot = {
+                ...this.contentFields(revision.snapshot, await this.snapshotOf(current, manager)),
+                tagIds: revision.snapshot.tagIds,
+                relatedPostIds: revision.snapshot.relatedPostIds ?? [],
+                permissionIds: revision.snapshot.permissionIds ?? [],
+            };
+            return this.commitUpdate(current, input.expectedVersion, snapshot, manager);
+        });
+    }
+    async listRevisions(id: number): Promise<TaonCmsContentRevisionEntity[]> {
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => {
+            await this.requireContent(id, manager);
+            return this.taonCmsContentRevisionRepository.listForContent(id, manager);
+        });
+    }
+    async listRelatedPosts(id: number): Promise<TaonCmsContentEntity[]> {
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => (await this.requireContent(id, manager)).relatedPosts);
+    }
+    async listPermissions(id: number): Promise<TaonPermissionEntity[]> {
+        requireContentId(id);
+        return this.connection.transaction(async (manager) => (await this.requireContent(id, manager)).permissions);
+    }
+    async listApplicationHooks(): Promise<TaonCmsApplicationHookEntity[]> {
+        return this.connection
+            .getRepository(TaonCmsApplicationHookEntity)
+            .find({ order: { hook: 'ASC' } });
+    }
+    async getContentByHook(hook: string): Promise<string> {
+        if (!hook) {
+            contentError('Application hook is required.');
+        }
+        const applicationHook = await this.connection
+            .getRepository(TaonCmsApplicationHookEntity)
+            .findOne({
+            where: { hook: hook as TaonCmsApplicationHook },
+            relations: { content: true },
+        });
+        return applicationHook?.content?.body ?? '';
+    }
+    async addRelatedPost(id: number, relatedPostId: number, expectedVersion: number): Promise<TaonCmsContentEntity> {
+        return this.changeRelatedPost(id, relatedPostId, expectedVersion, true);
+    }
+    async deleteRelatedPost(id: number, relatedPostId: number, expectedVersion: number): Promise<TaonCmsContentEntity> {
+        return this.changeRelatedPost(id, relatedPostId, expectedVersion, false);
+    }
+    private async changeRelatedPost(id: number, relatedPostId: number, expectedVersion: number, adding: boolean): Promise<TaonCmsContentEntity> {
+        requireContentId(id);
+        requireContentId(relatedPostId, 'relatedPostId');
+        requireContentVersion(expectedVersion);
+        if (id === relatedPostId) {
+            contentError('A post cannot relate to itself.');
+        }
+        return this.connection.transaction(async (manager) => {
+            const current = await this.requireContent(id, manager);
+            await this.requireContent(relatedPostId, manager);
+            const snapshot = await this.snapshotOf(current, manager);
+            const ids = snapshot.relatedPostIds ?? [];
+            snapshot.relatedPostIds = adding
+                ? [...new Set([...ids, relatedPostId])]
+                : ids.filter(postId => postId !== relatedPostId);
+            return this.commitUpdate(current, expectedVersion, snapshot, manager);
+        });
+    }
+    private async requireContent(id: number, manager: EntityManager): Promise<TaonCmsContentEntity> {
+        const content = await manager
+            .getRepository<TaonCmsContentEntity>(this.target)
+            .findOne({
+            where: { id },
+            relations: {
+                relatedPosts: true,
+                permissions: true,
+                applicationHook: true,
+            },
+        });
+        if (!content) {
+            contentError(`Content ${id} does not exist.`, 404);
+        }
+        return content;
+    }
+    private contentFields(input: Partial<TaonCmsContentFields>, current?: TaonCmsContentFields): TaonCmsContentFields {
+        const type = input.type ?? current?.type ?? TaonCmsContentType.Normal;
+        const title = input.title ?? current?.title;
+        const slug = input.slug ?? current?.slug;
+        if (title === undefined || slug === undefined) {
+            contentError('title and slug are required.');
+        }
+        const publishedAt = input.publishedAt === undefined
+            ? (current?.publishedAt ?? null)
+            : input.publishedAt;
+        return {
+            type,
+            title,
+            slug,
+            body: input.body === undefined ? (current?.body ?? null) : input.body,
+            videoKey: input.videoKey === undefined ? (current?.videoKey ?? null) : input.videoKey,
+            audioKey: input.audioKey === undefined ? (current?.audioKey ?? null) : input.audioKey,
+            attachmentKey: input.attachmentKey === undefined
+                ? (current?.attachmentKey ?? null)
+                : input.attachmentKey,
+            excerpt: input.excerpt === undefined
+                ? (current?.excerpt ?? null)
+                : input.excerpt,
+            categoryId: input.categoryId === undefined
+                ? (current?.categoryId ?? null)
+                : input.categoryId,
+            authorUserId: input.authorUserId === undefined
+                ? (current?.authorUserId ?? null)
+                : input.authorUserId,
+            status: input.status ?? current?.status ?? 'draft',
+            publishedAt: publishedAt === null ? null : new Date(publishedAt),
+        };
+    }
+    private async snapshotOf(content: TaonCmsContentEntity, manager: EntityManager): Promise<TaonCmsContentSnapshot> {
+        return {
+            ...this.contentFields({
+                ...content,
+                status: this.contentStatus(content.status),
+            }),
+            tagIds: await this.taonCmsContentTagRepository.findTagIds(content.id, manager),
+            relatedPostIds: content.relatedPosts.map(post => post.id),
+            permissionIds: content.permissions.map(permission => permission.id),
+        };
+    }
+    private contentStatus(status: string): TaonCmsContentFields['status'] {
+        if (status !== 'draft' && status !== 'published' && status !== 'archived') {
+            contentError(`Unsupported stored content status: ${status}.`, 409);
+        }
+        return status;
+    }
+    private async validateReferences(fields: TaonCmsContentFields, tagIds: number[], permissionIds: number[], manager: EntityManager): Promise<void> {
+        if (fields.categoryId !== null) {
+            await this.taonCmsCategoryRepository.requireCategory(fields.categoryId, manager);
+        }
+        await this.tags.requireTags(tagIds, manager);
+        await this.requirePermissions(permissionIds, manager);
+    }
+    private async requirePermissions(permissionIds: number[], manager: EntityManager): Promise<void> {
+        if (!permissionIds.length) {
+            return;
+        }
+        const permissions = await manager
+            .getRepository<TaonPermissionEntity>(TaonPermissionEntity)
+            .findBy({ id: In(permissionIds) });
+        const foundIds = new Set(permissions.map(permission => permission.id));
+        const missingId = permissionIds.find(id => !foundIds.has(id));
+        if (missingId !== undefined) {
+            contentError(`Permission ${missingId} does not exist.`, 404);
+        }
+    }
+    private async requireAvailableSlug(slug: string, manager: EntityManager, contentId?: number): Promise<void> {
+        const existing = await manager
+            .getRepository<TaonCmsContentEntity>(this.target)
+            .findOneBy({ slug });
+        if (existing && existing.id !== contentId) {
+            contentError(`Slug "${slug}" is already in use.`, 409);
+        }
+    }
+    private async replaceRelatedPosts(id: number, relatedPostIds: number[], previousIds: number[], manager: EntityManager): Promise<void> {
+        if (relatedPostIds.includes(id)) {
+            contentError('A post cannot relate to itself.');
+        }
+        const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+        if (relatedPostIds.length) {
+            const posts = await repository.findBy({ id: In(relatedPostIds) });
+            const foundIds = new Set(posts.map(post => post.id));
+            const missingId = relatedPostIds.find(postId => !foundIds.has(postId));
+            if (missingId !== undefined) {
+                contentError(`Content ${missingId} does not exist.`, 404);
+            }
+        }
+        const added = relatedPostIds.filter(postId => !previousIds.includes(postId));
+        const removed = previousIds.filter(postId => !relatedPostIds.includes(postId));
+        if (added.length || removed.length) {
+            await repository.createQueryBuilder()
+                .relation('relatedPosts')
+                .of(id)
+                .addAndRemove(added, removed);
+        }
+    }
+    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));
+        if (added.length || removed.length) {
+            await manager
+                .getRepository<TaonCmsContentEntity>(this.target)
+                .createQueryBuilder()
+                .relation('permissions')
+                .of(id)
+                .addAndRemove(added, removed);
+        }
+    }
+    private async replaceApplicationHook(contentId: number, hook: TaonCmsApplicationHook | null, manager: EntityManager): Promise<void> {
+        const repository = manager.getRepository(TaonCmsApplicationHookEntity);
+        const current = await repository.findOneBy({ contentId });
+        if (hook === null) {
+            if (current) {
+                current.contentId = null;
+                await repository.save(current);
+            }
+            return;
+        }
+        const target = await repository.findOneBy({ hook });
+        if (!target) {
+            contentError(`Application hook "${hook}" is not configured.`, 404);
+        }
+        if (target.contentId !== null && target.contentId !== contentId) {
+            contentError(`Application hook "${hook}" is already in use.`, 409);
+        }
+        if (current?.id === target.id) {
+            return;
+        }
+        if (current) {
+            current.contentId = null;
+            await repository.save(current);
+        }
+        target.contentId = contentId;
+        await repository.save(target);
+    }
+    private async commitUpdate(current: TaonCmsContentEntity, expectedVersion: number, snapshot: TaonCmsContentSnapshot, manager: EntityManager, applicationHook?: TaonCmsApplicationHook | null): Promise<TaonCmsContentEntity> {
+        if (current.version !== expectedVersion) {
+            contentError('Content has changed. Reload it before editing.', 409);
+        }
+        await this.validateReferences(snapshot, snapshot.tagIds, snapshot.permissionIds, manager);
+        await this.requireAvailableSlug(snapshot.slug, manager, current.id);
+        const history = await this.taonCmsContentRevisionRepository.listForContent(current.id, manager);
+        if (!history.some(revision => revision.revisionNumber === current.version)) {
+            await this.taonCmsContentRevisionRepository.recordContent(current, await this.snapshotOf(current, manager), manager);
+        }
+        const fields = this.contentFields(snapshot);
+        const repository = manager.getRepository<TaonCmsContentEntity>(this.target);
+        const result = await repository.update({ id: current.id, version: expectedVersion }, { ...fields, version: expectedVersion + 1, updatedAt: new Date() });
+        if (result.affected !== 1) {
+            contentError('Content has changed. Reload it before editing.', 409);
+        }
+        await this.taonCmsContentTagRepository.replaceTags(current.id, snapshot.tagIds, manager);
+        await this.replaceRelatedPosts(current.id, [...new Set(snapshot.relatedPostIds ?? [])], current.relatedPosts.map(post => post.id), manager);
+        await this.replacePermissions(current.id, [...new Set(snapshot.permissionIds ?? [])], current.permissions.map(permission => permission.id), manager);
+        if (applicationHook !== undefined) {
+            await this.replaceApplicationHook(current.id, applicationHook, manager);
+        }
+        const updated = await this.requireContent(current.id, manager);
+        await this.taonCmsContentRevisionRepository.recordContent(updated, {
+            ...fields,
+            tagIds: snapshot.tagIds,
+            relatedPostIds: updated.relatedPosts.map(post => post.id),
+            permissionIds: updated.permissions.map(permission => permission.id),
+        }, manager);
+        return updated;
+    }
+    async countEntitesWithEvenId(): Promise<number> {
+        const result = await this.count({
+            where: {
+                id: Raw(alias => `${alias} % 2 = 0`),
+            },
+        });
+        return result;
+    }
+}

package/ts-source/websql-code/taon-cms-content/taon-cms-content.subscriber.ts

@@ -0,0 +1,24 @@
+// @ts-nocheck
+/* ============================================================================
+
+- TAON READONLY SOURCE
+- DO NOT MODIFY THIS FILE.
+- Changes may be overwritten.
+- Use command: taon build:watch:lib
+  inside @taon-dev/cms project repository
+  for watch development of third party modules like this.
+  
+ * ========================================================================== */
+
+import { TaonBaseSubscriberForEntity, TaonSubscriber } from 'taon/websql';
+import { TaonCmsContentEntity } from './taon-cms-content.entity';
+import { TaonCmsContentProvider } from './taon-cms-content.provider';
+@TaonSubscriber<TaonCmsContentSubscriber>({
+    className: 'TaonCmsContentSubscriber',
+})
+export class TaonCmsContentSubscriber extends TaonBaseSubscriberForEntity {
+    taonCmsContentProvider = this.injectProvider(TaonCmsContentProvider);
+    listenTo(): typeof TaonCmsContentEntity {
+        return TaonCmsContentEntity;
+    }
+}

package/ts-source/websql-code/taon-cms-content/taon-cms-content.utils.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+/* ============================================================================
+
+- TAON READONLY SOURCE
+- DO NOT MODIFY THIS FILE.
+- Changes may be overwritten.
+- Use command: taon build:watch:lib
+  inside @taon-dev/cms project repository
+  for watch development of third party modules like this.
+  
+ * ========================================================================== */
+
+import { TaonCmsContentState } from './taon-cms-content.models';
+export namespace TaonCmsContentUtils {
+    export function isActive(state: string): state is TaonCmsContentState {
+        return state === 'active';
+    }
+}