@rytass/cms-base-nestjs-module/index.cjs.js

Rytass Content Management System NestJS Base Module

'use strict';

var common = require('@nestjs/common');
var typeorm$1 = require('@nestjs/typeorm');
var typeorm = require('typeorm');
var core = require('@quadrats/core');
var DataLoader = require('dataloader');
var lruCache = require('lru-cache');

const DEFAULT_LANGUAGE = 'DEFAULT';

const FULL_TEXT_SEARCH_TOKEN_VERSION = '0.0.1';

const EMPTY_QUADRATS_ELEMENTS = [
    {
        type: core.PARAGRAPH_TYPE,
        children: [
            {
                text: ''
            }
        ]
    }
];

function _ts_decorate$h(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$f(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const BaseArticleVersionContentRepo = Symbol('BaseArticleVersionContentRepo');
class BaseArticleVersionContentEntity {
    articleId;
    version;
    language;
    title;
    description;
    content;
    searchTokens;
    searchTokenVersion;
    articleVersion;
}
_ts_decorate$h([
    typeorm.PrimaryColumn('uuid'),
    _ts_metadata$f("design:type", String)
], BaseArticleVersionContentEntity.prototype, "articleId", void 0);
_ts_decorate$h([
    typeorm.PrimaryColumn('int', {
        default: 0
    }),
    _ts_metadata$f("design:type", Number)
], BaseArticleVersionContentEntity.prototype, "version", void 0);
_ts_decorate$h([
    typeorm.PrimaryColumn('varchar', {
        default: DEFAULT_LANGUAGE
    }),
    _ts_metadata$f("design:type", String)
], BaseArticleVersionContentEntity.prototype, "language", void 0);
_ts_decorate$h([
    typeorm.Column('varchar'),
    typeorm.Index(),
    _ts_metadata$f("design:type", String)
], BaseArticleVersionContentEntity.prototype, "title", void 0);
_ts_decorate$h([
    typeorm.Column('varchar', {
        nullable: true,
        comment: 'Use for SEO'
    }),
    typeorm.Index(),
    _ts_metadata$f("design:type", Object)
], BaseArticleVersionContentEntity.prototype, "description", void 0);
_ts_decorate$h([
    typeorm.Column('json', {
        default: EMPTY_QUADRATS_ELEMENTS
    }),
    _ts_metadata$f("design:type", Array)
], BaseArticleVersionContentEntity.prototype, "content", void 0);
_ts_decorate$h([
    typeorm.Column('tsvector', {
        nullable: true,
        select: false
    }),
    _ts_metadata$f("design:type", Object)
], BaseArticleVersionContentEntity.prototype, "searchTokens", void 0);
_ts_decorate$h([
    typeorm.Column('varchar', {
        default: FULL_TEXT_SEARCH_TOKEN_VERSION,
        select: false
    }),
    _ts_metadata$f("design:type", String)
], BaseArticleVersionContentEntity.prototype, "searchTokenVersion", void 0);
_ts_decorate$h([
    typeorm.ManyToOne(()=>BaseArticleVersionEntity, (articleVersion)=>articleVersion.multiLanguageContents, {
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE',
        orphanedRowAction: 'delete'
    }),
    typeorm.JoinColumn([
        {
            name: 'articleId',
            referencedColumnName: 'articleId'
        },
        {
            name: 'version',
            referencedColumnName: 'version'
        }
    ]),
    _ts_metadata$f("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseArticleVersionContentEntity.prototype, "articleVersion", void 0);
BaseArticleVersionContentEntity = _ts_decorate$h([
    typeorm.Entity('article_version_contents'),
    typeorm.Index([
        'articleId',
        'version'
    ]),
    typeorm.TableInheritance({
        column: {
            type: 'varchar',
            name: 'entityName'
        }
    })
], BaseArticleVersionContentEntity);

var ArticleSignatureResult = /*#__PURE__*/ function(ArticleSignatureResult) {
    ArticleSignatureResult["APPROVED"] = "APPROVED";
    ArticleSignatureResult["REJECTED"] = "REJECTED";
    return ArticleSignatureResult;
}({});

function _ts_decorate$g(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$e(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const BaseSignatureLevelRepo = Symbol('BaseSignatureLevelRepo');
class BaseSignatureLevelEntity {
    id;
    name;
    sequence;
    required;
    createdAt;
    deletedAt;
    signatures;
}
_ts_decorate$g([
    typeorm.PrimaryGeneratedColumn('uuid'),
    _ts_metadata$e("design:type", String)
], BaseSignatureLevelEntity.prototype, "id", void 0);
_ts_decorate$g([
    typeorm.Column('varchar'),
    _ts_metadata$e("design:type", String)
], BaseSignatureLevelEntity.prototype, "name", void 0);
_ts_decorate$g([
    typeorm.Column('int', {
        default: 0
    }),
    typeorm.Index({
        unique: true,
        where: '"deletedAt" IS NULL'
    }),
    _ts_metadata$e("design:type", Number)
], BaseSignatureLevelEntity.prototype, "sequence", void 0);
_ts_decorate$g([
    typeorm.Column('boolean', {
        default: true
    }),
    _ts_metadata$e("design:type", Boolean)
], BaseSignatureLevelEntity.prototype, "required", void 0);
_ts_decorate$g([
    typeorm.CreateDateColumn(),
    _ts_metadata$e("design:type", typeof Date === "undefined" ? Object : Date)
], BaseSignatureLevelEntity.prototype, "createdAt", void 0);
_ts_decorate$g([
    typeorm.DeleteDateColumn(),
    _ts_metadata$e("design:type", Object)
], BaseSignatureLevelEntity.prototype, "deletedAt", void 0);
_ts_decorate$g([
    typeorm.OneToMany(()=>ArticleSignatureEntity, (signature)=>signature.signatureLevel),
    _ts_metadata$e("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseSignatureLevelEntity.prototype, "signatures", void 0);
BaseSignatureLevelEntity = _ts_decorate$g([
    typeorm.Entity('signature_levels'),
    typeorm.TableInheritance({
        column: {
            type: 'varchar',
            name: 'entityName'
        }
    })
], BaseSignatureLevelEntity);

function _ts_decorate$f(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$d(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const ArticleSignatureRepo = Symbol('ArticleSignatureRepo');
class ArticleSignatureEntity {
    id;
    articleId;
    version;
    signatureLevelId;
    result;
    rejectReason;
    signerId;
    signedAt;
    deletedAt;
    articleVersion;
    signatureLevel;
}
_ts_decorate$f([
    typeorm.PrimaryGeneratedColumn('uuid'),
    _ts_metadata$d("design:type", String)
], ArticleSignatureEntity.prototype, "id", void 0);
_ts_decorate$f([
    typeorm.Column('uuid'),
    _ts_metadata$d("design:type", String)
], ArticleSignatureEntity.prototype, "articleId", void 0);
_ts_decorate$f([
    typeorm.Column('int'),
    _ts_metadata$d("design:type", Number)
], ArticleSignatureEntity.prototype, "version", void 0);
_ts_decorate$f([
    typeorm.Column('uuid', {
        nullable: true
    }),
    typeorm.Index(),
    _ts_metadata$d("design:type", Object)
], ArticleSignatureEntity.prototype, "signatureLevelId", void 0);
_ts_decorate$f([
    typeorm.Column('enum', {
        enum: ArticleSignatureResult,
        default: ArticleSignatureResult.APPROVED
    }),
    _ts_metadata$d("design:type", typeof ArticleSignatureResult === "undefined" ? Object : ArticleSignatureResult)
], ArticleSignatureEntity.prototype, "result", void 0);
_ts_decorate$f([
    typeorm.Column('varchar', {
        nullable: true
    }),
    _ts_metadata$d("design:type", Object)
], ArticleSignatureEntity.prototype, "rejectReason", void 0);
_ts_decorate$f([
    typeorm.Column('uuid', {
        nullable: true
    }),
    _ts_metadata$d("design:type", Object)
], ArticleSignatureEntity.prototype, "signerId", void 0);
_ts_decorate$f([
    typeorm.CreateDateColumn(),
    _ts_metadata$d("design:type", typeof Date === "undefined" ? Object : Date)
], ArticleSignatureEntity.prototype, "signedAt", void 0);
_ts_decorate$f([
    typeorm.DeleteDateColumn(),
    _ts_metadata$d("design:type", Object)
], ArticleSignatureEntity.prototype, "deletedAt", void 0);
_ts_decorate$f([
    typeorm.ManyToOne(()=>BaseArticleVersionEntity, (version)=>version.signatures),
    typeorm.JoinColumn([
        {
            name: 'articleId',
            referencedColumnName: 'articleId'
        },
        {
            name: 'version',
            referencedColumnName: 'version'
        }
    ]),
    _ts_metadata$d("design:type", typeof Relation === "undefined" ? Object : Relation)
], ArticleSignatureEntity.prototype, "articleVersion", void 0);
_ts_decorate$f([
    typeorm.ManyToOne(()=>BaseSignatureLevelEntity, (level)=>level.signatures, {
        nullable: true
    }),
    typeorm.JoinColumn({
        name: 'signatureLevelId',
        referencedColumnName: 'id'
    }),
    _ts_metadata$d("design:type", Object)
], ArticleSignatureEntity.prototype, "signatureLevel", void 0);
ArticleSignatureEntity = _ts_decorate$f([
    typeorm.Entity('article_signatures'),
    typeorm.Index('article_signature_article_id_version', [
        'articleId',
        'version',
        'signatureLevelId'
    ], {
        unique: true,
        where: '"deletedAt" IS NULL'
    }),
    typeorm.Index([
        'articleId',
        'version'
    ])
], ArticleSignatureEntity);

function _ts_decorate$e(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$c(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const BaseArticleVersionRepo = Symbol('BaseArticleVersionRepo');
class BaseArticleVersionEntity {
    articleId;
    version;
    tags;
    submittedAt;
    submittedBy;
    releasedAt;
    releasedBy;
    createdAt;
    createdBy;
    deletedAt;
    article;
    multiLanguageContents;
    signatures;
}
_ts_decorate$e([
    typeorm.PrimaryColumn('uuid'),
    typeorm.Index(),
    _ts_metadata$c("design:type", String)
], BaseArticleVersionEntity.prototype, "articleId", void 0);
_ts_decorate$e([
    typeorm.PrimaryColumn('int', {
        default: 0
    }),
    _ts_metadata$c("design:type", Number)
], BaseArticleVersionEntity.prototype, "version", void 0);
_ts_decorate$e([
    typeorm.Column('jsonb', {
        default: /* istanbul ignore next: TypeORM default function */ ()=>"'[]'::jsonb"
    }),
    _ts_metadata$c("design:type", Array)
], BaseArticleVersionEntity.prototype, "tags", void 0);
_ts_decorate$e([
    typeorm.Column('timestamptz', {
        nullable: true
    }),
    typeorm.Index(),
    _ts_metadata$c("design:type", Object)
], BaseArticleVersionEntity.prototype, "submittedAt", void 0);
_ts_decorate$e([
    typeorm.Column('uuid', {
        nullable: true
    }),
    _ts_metadata$c("design:type", Object)
], BaseArticleVersionEntity.prototype, "submittedBy", void 0);
_ts_decorate$e([
    typeorm.Column('timestamptz', {
        nullable: true
    }),
    typeorm.Index(),
    _ts_metadata$c("design:type", Object)
], BaseArticleVersionEntity.prototype, "releasedAt", void 0);
_ts_decorate$e([
    typeorm.Column('uuid', {
        nullable: true
    }),
    _ts_metadata$c("design:type", Object)
], BaseArticleVersionEntity.prototype, "releasedBy", void 0);
_ts_decorate$e([
    typeorm.CreateDateColumn(),
    _ts_metadata$c("design:type", typeof Date === "undefined" ? Object : Date)
], BaseArticleVersionEntity.prototype, "createdAt", void 0);
_ts_decorate$e([
    typeorm.Column('uuid', {
        nullable: true
    }),
    _ts_metadata$c("design:type", Object)
], BaseArticleVersionEntity.prototype, "createdBy", void 0);
_ts_decorate$e([
    typeorm.DeleteDateColumn(),
    _ts_metadata$c("design:type", Object)
], BaseArticleVersionEntity.prototype, "deletedAt", void 0);
_ts_decorate$e([
    typeorm.ManyToOne(()=>BaseArticleEntity, (article)=>article.versions, {
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE',
        orphanedRowAction: 'delete'
    }),
    typeorm.JoinColumn({
        name: 'articleId',
        referencedColumnName: 'id'
    }),
    _ts_metadata$c("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseArticleVersionEntity.prototype, "article", void 0);
_ts_decorate$e([
    typeorm.OneToMany(()=>BaseArticleVersionContentEntity, (content)=>content.articleVersion),
    _ts_metadata$c("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseArticleVersionEntity.prototype, "multiLanguageContents", void 0);
_ts_decorate$e([
    typeorm.OneToMany(()=>ArticleSignatureEntity, (signature)=>signature.articleVersion),
    _ts_metadata$c("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseArticleVersionEntity.prototype, "signatures", void 0);
BaseArticleVersionEntity = _ts_decorate$e([
    typeorm.Entity('article_versions'),
    typeorm.TableInheritance({
        column: {
            type: 'varchar',
            name: 'entityName'
        }
    })
], BaseArticleVersionEntity);

function _ts_decorate$d(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$b(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const BaseCategoryMultiLanguageNameRepo = Symbol('BaseCategoryMultiLanguageNameRepo');
class BaseCategoryMultiLanguageNameEntity {
    categoryId;
    language;
    name;
    createdAt;
    updatedAt;
    category;
}
_ts_decorate$d([
    typeorm.PrimaryColumn('uuid'),
    typeorm.Index(),
    _ts_metadata$b("design:type", String)
], BaseCategoryMultiLanguageNameEntity.prototype, "categoryId", void 0);
_ts_decorate$d([
    typeorm.PrimaryColumn('varchar', {
        default: DEFAULT_LANGUAGE
    }),
    _ts_metadata$b("design:type", typeof Language === "undefined" ? Object : Language)
], BaseCategoryMultiLanguageNameEntity.prototype, "language", void 0);
_ts_decorate$d([
    typeorm.Column('varchar'),
    _ts_metadata$b("design:type", String)
], BaseCategoryMultiLanguageNameEntity.prototype, "name", void 0);
_ts_decorate$d([
    typeorm.CreateDateColumn(),
    _ts_metadata$b("design:type", typeof Date === "undefined" ? Object : Date)
], BaseCategoryMultiLanguageNameEntity.prototype, "createdAt", void 0);
_ts_decorate$d([
    typeorm.UpdateDateColumn(),
    _ts_metadata$b("design:type", typeof Date === "undefined" ? Object : Date)
], BaseCategoryMultiLanguageNameEntity.prototype, "updatedAt", void 0);
_ts_decorate$d([
    typeorm.ManyToOne(()=>BaseCategoryEntity, (category)=>category.multiLanguageNames, {
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE',
        orphanedRowAction: 'delete'
    }),
    typeorm.JoinColumn({
        name: 'categoryId',
        referencedColumnName: 'id'
    }),
    _ts_metadata$b("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseCategoryMultiLanguageNameEntity.prototype, "category", void 0);
BaseCategoryMultiLanguageNameEntity = _ts_decorate$d([
    typeorm.Entity('category_multi_language_names'),
    typeorm.TableInheritance({
        column: {
            type: 'varchar',
            name: 'entityName'
        }
    })
], BaseCategoryMultiLanguageNameEntity);

function _ts_decorate$c(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$a(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const BaseCategoryRepo = Symbol('BaseCategoryRepo');
class BaseCategoryEntity {
    id;
    bindable;
    createdAt;
    updatedAt;
    deletedAt;
    parents;
    children;
    multiLanguageNames;
    articles;
}
_ts_decorate$c([
    typeorm.PrimaryGeneratedColumn('uuid'),
    _ts_metadata$a("design:type", String)
], BaseCategoryEntity.prototype, "id", void 0);
_ts_decorate$c([
    typeorm.Column('boolean', {
        default: false,
        comment: 'is article bindable'
    }),
    _ts_metadata$a("design:type", Boolean)
], BaseCategoryEntity.prototype, "bindable", void 0);
_ts_decorate$c([
    typeorm.CreateDateColumn(),
    _ts_metadata$a("design:type", typeof Date === "undefined" ? Object : Date)
], BaseCategoryEntity.prototype, "createdAt", void 0);
_ts_decorate$c([
    typeorm.UpdateDateColumn(),
    _ts_metadata$a("design:type", typeof Date === "undefined" ? Object : Date)
], BaseCategoryEntity.prototype, "updatedAt", void 0);
_ts_decorate$c([
    typeorm.DeleteDateColumn(),
    _ts_metadata$a("design:type", Object)
], BaseCategoryEntity.prototype, "deletedAt", void 0);
_ts_decorate$c([
    typeorm.ManyToMany(()=>BaseCategoryEntity, (category)=>category.children),
    typeorm.JoinTable({
        name: 'category_relations',
        joinColumn: {
            name: 'childId',
            referencedColumnName: 'id'
        },
        inverseJoinColumn: {
            name: 'parentId',
            referencedColumnName: 'id'
        }
    }),
    _ts_metadata$a("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseCategoryEntity.prototype, "parents", void 0);
_ts_decorate$c([
    typeorm.ManyToMany(()=>BaseCategoryEntity, (category)=>category.parents, {
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE',
        orphanedRowAction: 'delete'
    }),
    _ts_metadata$a("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseCategoryEntity.prototype, "children", void 0);
_ts_decorate$c([
    typeorm.OneToMany(()=>BaseCategoryMultiLanguageNameEntity, (multiLanguageName)=>multiLanguageName.category),
    _ts_metadata$a("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseCategoryEntity.prototype, "multiLanguageNames", void 0);
_ts_decorate$c([
    typeorm.ManyToMany(()=>BaseArticleEntity, (article)=>article.categories, {
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE',
        orphanedRowAction: 'delete'
    }),
    _ts_metadata$a("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseCategoryEntity.prototype, "articles", void 0);
BaseCategoryEntity = _ts_decorate$c([
    typeorm.Entity('categories'),
    typeorm.TableInheritance({
        column: {
            type: 'varchar',
            name: 'entityName'
        }
    })
], BaseCategoryEntity);

function _ts_decorate$b(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$9(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const BaseArticleRepo = Symbol('BaseArticleRepo');
class BaseArticleEntity {
    id;
    createdAt;
    deletedAt;
    versions;
    categories;
}
_ts_decorate$b([
    typeorm.PrimaryGeneratedColumn('uuid'),
    _ts_metadata$9("design:type", String)
], BaseArticleEntity.prototype, "id", void 0);
_ts_decorate$b([
    typeorm.CreateDateColumn(),
    _ts_metadata$9("design:type", typeof Date === "undefined" ? Object : Date)
], BaseArticleEntity.prototype, "createdAt", void 0);
_ts_decorate$b([
    typeorm.DeleteDateColumn(),
    _ts_metadata$9("design:type", Object)
], BaseArticleEntity.prototype, "deletedAt", void 0);
_ts_decorate$b([
    typeorm.OneToMany(()=>BaseArticleVersionEntity, (articleVersion)=>articleVersion.article),
    _ts_metadata$9("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseArticleEntity.prototype, "versions", void 0);
_ts_decorate$b([
    typeorm.ManyToMany(()=>BaseCategoryEntity, (category)=>category.articles),
    typeorm.JoinTable({
        name: 'article_categories',
        joinColumn: {
            name: 'articleId',
            referencedColumnName: 'id'
        },
        inverseJoinColumn: {
            name: 'categoryId',
            referencedColumnName: 'id'
        }
    }),
    _ts_metadata$9("design:type", typeof Relation === "undefined" ? Object : Relation)
], BaseArticleEntity.prototype, "categories", void 0);
BaseArticleEntity = _ts_decorate$b([
    typeorm.Entity('articles'),
    typeorm.TableInheritance({
        column: {
            type: 'varchar',
            name: 'entityName'
        }
    })
], BaseArticleEntity);

function _ts_decorate$a(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$8(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const CategoryRelationRepo = Symbol('CategoryRelationRepo');
class CategoryRelationEntity {
    parentId;
    childId;
}
_ts_decorate$a([
    typeorm.PrimaryColumn('uuid'),
    _ts_metadata$8("design:type", String)
], CategoryRelationEntity.prototype, "parentId", void 0);
_ts_decorate$a([
    typeorm.PrimaryColumn('uuid'),
    _ts_metadata$8("design:type", String)
], CategoryRelationEntity.prototype, "childId", void 0);
CategoryRelationEntity = _ts_decorate$a([
    typeorm.Entity('category_relations')
], CategoryRelationEntity);

function _ts_decorate$9(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$7(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
const ArticleCategoryRepo = Symbol('ArticleCategoryRepo');
class ArticleCategoryEntity {
    articleId;
    categoryId;
}
_ts_decorate$9([
    typeorm.PrimaryColumn('uuid'),
    _ts_metadata$7("design:type", String)
], ArticleCategoryEntity.prototype, "articleId", void 0);
_ts_decorate$9([
    typeorm.PrimaryColumn('uuid'),
    _ts_metadata$7("design:type", String)
], ArticleCategoryEntity.prototype, "categoryId", void 0);
ArticleCategoryEntity = _ts_decorate$9([
    typeorm.Entity('article_categories')
], ArticleCategoryEntity);

function _ts_decorate$8(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
const models = [
    [
        BaseArticleRepo,
        BaseArticleEntity
    ],
    [
        BaseArticleVersionRepo,
        BaseArticleVersionEntity
    ],
    [
        BaseArticleVersionContentRepo,
        BaseArticleVersionContentEntity
    ],
    [
        BaseCategoryRepo,
        BaseCategoryEntity
    ],
    [
        BaseCategoryMultiLanguageNameRepo,
        BaseCategoryMultiLanguageNameEntity
    ],
    [
        BaseSignatureLevelRepo,
        BaseSignatureLevelEntity
    ],
    [
        CategoryRelationRepo,
        CategoryRelationEntity
    ],
    [
        ArticleCategoryRepo,
        ArticleCategoryEntity
    ],
    [
        ArticleSignatureRepo,
        ArticleSignatureEntity
    ]
];
class CMSBaseModelsModule {
}
CMSBaseModelsModule = _ts_decorate$8([
    common.Module({
        imports: [
            typeorm$1.TypeOrmModule.forFeature(models.map((model)=>model[1]))
        ],
        providers: models.map(([symbol, entity])=>({
                provide: symbol,
                useFactory: (dataSource)=>dataSource.getRepository(entity),
                inject: [
                    typeorm.DataSource
                ]
            })),
        exports: models.map((model)=>model[0])
    })
], CMSBaseModelsModule);

const CMS_BASE_MODULE_OPTIONS = Symbol('CMS_BASE_MODULE_OPTIONS');
const MULTIPLE_LANGUAGE_MODE = Symbol('MULTIPLE_LANGUAGE_MODE');
const MULTIPLE_CATEGORY_PARENT_MODE = Symbol('MULTIPLE_CATEGORY_PARENT_MODE');
const CIRCULAR_CATEGORY_MODE = Symbol('CIRCULAR_CATEGORY_MODE');
const FULL_TEXT_SEARCH_MODE = Symbol('FULL_TEXT_SEARCH_MODE');
const SIGNATURE_LEVELS = Symbol('SIGNATURE_LEVELS');
const DRAFT_MODE = Symbol('DRAFT_MODE');
const AUTO_RELEASE_AFTER_APPROVED = Symbol('AUTO_RELEASE_AFTER_APPROVED');
// Options Entity Providers
const PROVIDE_ARTICLE_ENTITY = Symbol('PROVIDE_ARTICLE_ENTITY');
const PROVIDE_ARTICLE_VERSION_ENTITY = Symbol('PROVIDE_ARTICLE_VERSION_ENTITY');
const PROVIDE_ARTICLE_VERSION_CONTENT_ENTITY = Symbol('PROVIDE_ARTICLE_VERSION_CONTENT_ENTITY');
const PROVIDE_CATEGORY_ENTITY = Symbol('PROVIDE_CATEGORY_ENTITY');
const PROVIDE_CATEGORY_MULTI_LANGUAGE_NAME_ENTITY = Symbol('PROVIDE_CATEGORY_MULTI_LANGUAGE_NAME_ENTITY');
const PROVIDE_SIGNATURE_LEVEL_ENTITY = Symbol('PROVIDE_SIGNATURE_LEVEL_ENTITY');
// Resolved Entity Repository Providers
const RESOLVED_ARTICLE_REPO = Symbol('RESOLVED_ARTICLE_REPO');
const RESOLVED_ARTICLE_VERSION_REPO = Symbol('RESOLVED_ARTICLE_VERSION_REPO');
const RESOLVED_ARTICLE_VERSION_CONTENT_REPO = Symbol('RESOLVED_ARTICLE_VERSION_CONTENT_REPO');
const RESOLVED_CATEGORY_REPO = Symbol('RESOLVED_CATEGORY_REPO');
const RESOLVED_CATEGORY_MULTI_LANGUAGE_NAME_REPO = Symbol('RESOLVED_CATEGORY_MULTI_LANGUAGE_NAME_REPO');
const RESOLVED_SIGNATURE_LEVEL_REPO = Symbol('RESOLVED_SIGNATURE_LEVEL_REPO');
// Internal Use Injection Token
const CATEGORY_DATA_LOADER = Symbol('CATEGORY_DATA_LOADER');
const ARTICLE_BASE_SERVICE = Symbol('ARTICLE_BASE_SERVICE');
const ARTICLE_SIGNATURE_DATALOADER = Symbol('ARTICLE_SIGNATURE_DATALOADER');

var ArticleSorter = /*#__PURE__*/ function(ArticleSorter) {
    ArticleSorter["CREATED_AT_DESC"] = "CREATED_AT_DESC";
    ArticleSorter["CREATED_AT_ASC"] = "CREATED_AT_ASC";
    ArticleSorter["UPDATED_AT_DESC"] = "UPDATED_AT_DESC";
    ArticleSorter["UPDATED_AT_ASC"] = "UPDATED_AT_ASC";
    ArticleSorter["SUBMITTED_AT_DESC"] = "SUBMITTED_AT_DESC";
    ArticleSorter["SUBMITTED_AT_ASC"] = "SUBMITTED_AT_ASC";
    ArticleSorter["RELEASED_AT_DESC"] = "RELEASED_AT_DESC";
    ArticleSorter["RELEASED_AT_ASC"] = "RELEASED_AT_ASC";
    return ArticleSorter;
}({});

class MultipleLanguageModeIsDisabledError extends common.BadRequestException {
    constructor(){
        super('Multiple language mode is disabled');
    }
    code = 100;
}

class ArticleNotFoundError extends common.BadRequestException {
    constructor(){
        super('Article not found');
    }
    code = 200;
}
class ArticleVersionNotFoundError extends common.BadRequestException {
    constructor(){
        super('Article version not found');
    }
    code = 201;
}

class CategoryNotFoundError extends common.BadRequestException {
    constructor(){
        super('Category not found');
    }
    code = 300;
}
class CircularCategoryNotAllowedError extends common.BadRequestException {
    constructor(){
        super('Circular category is not allowed');
    }
    code = 301;
}
class MultipleParentCategoryNotAllowedError extends common.BadRequestException {
    constructor(){
        super('Multiple parent categories not allowed, please enable on module forRoot options');
    }
    code = 302;
}
class ParentCategoryNotFoundError extends common.BadRequestException {
    constructor(){
        super('Parent category not found');
    }
    code = 303;
}

var ArticleSearchMode = /*#__PURE__*/ function(ArticleSearchMode) {
    ArticleSearchMode["FULL_TEXT"] = "full_text";
    ArticleSearchMode["TITLE"] = "title";
    ArticleSearchMode["TITLE_AND_TAG"] = "title-and-tag";
    return ArticleSearchMode;
}({});

var ArticleStage = /*#__PURE__*/ function(ArticleStage) {
    ArticleStage["DRAFT"] = "DRAFT";
    ArticleStage["REVIEWING"] = "REVIEWING";
    ArticleStage["VERIFIED"] = "VERIFIED";
    ArticleStage["SCHEDULED"] = "SCHEDULED";
    ArticleStage["RELEASED"] = "RELEASED";
    ArticleStage["DELETED"] = "DELETED";
    ArticleStage["UNKNOWN"] = "UNKNOWN";
    return ArticleStage;
}({});

const ArticleNotIncludeFields = [
    'id',
    'createdAt',
    'deletedAt',
    'versions',
    'categories'
];
const ArticleVersionNotIncludeFields = [
    ...ArticleNotIncludeFields,
    'articleId',
    'article',
    'multiLanguageContents',
    'signatures'
];
const ArticleVersionContentNotIncludeFields = [
    ...ArticleVersionNotIncludeFields,
    'version',
    'language',
    'articleVersion'
];

function removeArticleInvalidFields(article) {
    return Object.entries(article).filter(([key])=>!~ArticleNotIncludeFields.indexOf(key)).reduce((vars, [key, value])=>({
            ...vars,
            [key]: value
        }), {});
}
function removeMultipleLanguageArticleVersionInvalidFields(articleVersion) {
    return Object.entries(articleVersion).filter(([key])=>!ArticleVersionNotIncludeFields.includes(key) || key === 'multiLanguageContents').reduce((vars, [key, value])=>({
            ...vars,
            [key]: value
        }), {});
}
function removeArticleVersionInvalidFields(articleVersion) {
    return Object.entries(articleVersion).filter(([key])=>!ArticleVersionNotIncludeFields.includes(key)).reduce((vars, [key, value])=>({
            ...vars,
            [key]: value
        }), {});
}
function removeArticleVersionContentInvalidFields(articleVersionContent) {
    return Object.entries(articleVersionContent).filter(([key])=>!~ArticleVersionContentNotIncludeFields.indexOf(key)).reduce((vars, [key, value])=>({
            ...vars,
            [key]: value
        }), {});
}

function _ts_decorate$7(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$6(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
function _ts_param$6(paramIndex, decorator) {
    return function(target, key) {
        decorator(target, key, paramIndex);
    };
}
class SignatureService {
    signatureLevels;
    signatureLevelRepo;
    dataSource;
    articleSignatureRepo;
    constructor(signatureLevels, signatureLevelRepo, dataSource, articleSignatureRepo){
        this.signatureLevels = signatureLevels;
        this.signatureLevelRepo = signatureLevelRepo;
        this.dataSource = dataSource;
        this.articleSignatureRepo = articleSignatureRepo;
    }
    get signatureEnabled() {
        return this.signatureLevels.length > 0;
    }
    signatureLevelsCache = [];
    get finalSignatureLevel() {
        return this.signatureLevelsCache[this.signatureLevelsCache.length - 1] ?? null;
    }
    async onApplicationBootstrap() {
        if (this.signatureEnabled) {
            const signatureLevels = await this.signatureLevelRepo.find();
            const existedMap = new Map(signatureLevels.map((level)=>[
                    level.name,
                    level
                ]));
            const usedSet = new Set();
            const targetLevelNames = new Set(this.signatureLevels.map((level)=>level instanceof BaseSignatureLevelEntity ? level.name : level));
            const runner = this.dataSource.createQueryRunner();
            await runner.connect();
            await runner.startTransaction();
            try {
                await signatureLevels.filter((level)=>!targetLevelNames.has(level.name)).map((level)=>async ()=>{
                        await runner.manager.delete(this.articleSignatureRepo.metadata.tableName, {
                            signatureLevelId: level.id
                        });
                        await runner.manager.softDelete(this.signatureLevelRepo.metadata.tableName, {
                            id: level.id
                        });
                    }).reduce((prev, next)=>prev.then(next), Promise.resolve());
                this.signatureLevelsCache = await this.signatureLevels.map((level, index)=>async (levels)=>{
                        if (level instanceof BaseSignatureLevelEntity) {
                            level.sequence = index;
                            level.required = true;
                            await runner.manager.save(level);
                            usedSet.add(level);
                            return [
                                ...levels,
                                level
                            ];
                        }
                        if (existedMap.has(level)) {
                            const existedLevel = existedMap.get(level);
                            existedLevel.sequence = index;
                            existedLevel.required = true;
                            await runner.manager.save(existedLevel);
                            usedSet.add(existedLevel);
                            return [
                                ...levels,
                                existedLevel
                            ];
                        }
                        const newLevel = this.signatureLevelRepo.create({
                            name: level,
                            required: true,
                            sequence: index
                        });
                        await runner.manager.save(newLevel);
                        usedSet.add(newLevel);
                        return levels;
                    }).reduce((prev, next)=>prev.then(next), Promise.resolve([]));
                await runner.commitTransaction();
            } catch (ex) {
                await runner.rollbackTransaction();
                throw ex;
            } finally{
                await runner.release();
            }
        }
    }
}
SignatureService = _ts_decorate$7([
    common.Injectable(),
    _ts_param$6(0, common.Inject(SIGNATURE_LEVELS)),
    _ts_param$6(1, common.Inject(RESOLVED_SIGNATURE_LEVEL_REPO)),
    _ts_param$6(2, typeorm$1.InjectDataSource()),
    _ts_param$6(3, common.Inject(ArticleSignatureRepo)),
    _ts_metadata$6("design:type", Function),
    _ts_metadata$6("design:paramtypes", [
        Array,
        typeof typeorm.Repository === "undefined" ? Object : typeorm.Repository,
        typeof typeorm.DataSource === "undefined" ? Object : typeorm.DataSource,
        typeof typeorm.Repository === "undefined" ? Object : typeorm.Repository
    ])
], SignatureService);

function _ts_decorate$6(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$5(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
function _ts_param$5(paramIndex, decorator) {
    return function(target, key) {
        decorator(target, key, paramIndex);
    };
}
class ArticleDataLoader {
    articleRepo;
    articleVersionRepo;
    signatureService;
    constructor(articleRepo, articleVersionRepo, signatureService){
        this.articleRepo = articleRepo;
        this.articleVersionRepo = articleVersionRepo;
        this.signatureService = signatureService;
    }
    stageCache = new lruCache.LRUCache({
        ttl: 1000 * 5,
        ttlAutopurge: true,
        max: 1000
    });
    stageLoader = new DataLoader(async (queryArgs)=>{
        const qb = this.articleVersionRepo.createQueryBuilder('versions');
        qb.withDeleted();
        qb.leftJoinAndSelect('versions.signatures', 'signatures');
        qb.andWhere(new typeorm.Brackets((subQb)=>{
            queryArgs.forEach((args, index)=>{
                subQb.orWhere(`versions.articleId = :id_${index} AND versions.version = :version_${index}`, {
                    [`id_${index}`]: args.id,
                    [`version_${index}`]: args.version
                });
            });
            return subQb;
        }));
        const versions = await qb.getMany();
        const versionMap = new Map(versions.map((version)=>[
                `${version.articleId}:${version.version}`,
                (()=>{
                    if (version.deletedAt) return ArticleStage.DELETED;
                    if (version.releasedAt) {
                        if (version.releasedAt.getTime() > Date.now()) {
                            return ArticleStage.SCHEDULED;
                        }
                        return ArticleStage.RELEASED;
                    }
                    if (version.signatures.some((sig)=>sig.result === ArticleSignatureResult.APPROVED && sig.deletedAt === null && sig.signatureLevelId === this.signatureService.finalSignatureLevel?.id)) {
                        return ArticleStage.VERIFIED;
                    }
                    if (version.submittedAt) {
                        return ArticleStage.REVIEWING;
                    }
                    return ArticleStage.DRAFT;
                })()
            ]));
        return queryArgs.map((args)=>versionMap.get(`${args.id}:${args.version}`) ?? ArticleStage.UNKNOWN);
    }, {
        cache: true,
        cacheMap: this.stageCache,
        cacheKeyFn: (queryArgs)=>`${queryArgs.id}:${queryArgs.version}`
    });
    categoriesLoader = new DataLoader(async (ids)=>{
        const qb = this.articleRepo.createQueryBuilder('articles');
        qb.leftJoinAndSelect('articles.categories', 'categories');
        qb.andWhere('articles.id IN (:...ids)', {
            ids
        });
        const articles = await qb.getMany();
        const categoryMap = new Map(articles.map((article)=>[
                article.id,
                article.categories
            ]));
        return ids.map((id)=>categoryMap.get(id) ?? []);
    }, {
        cache: true,
        cacheMap: new lruCache.LRUCache({
            ttl: 1000 * 60,
            ttlAutopurge: true,
            max: 1000
        })
    });
}
ArticleDataLoader = _ts_decorate$6([
    common.Injectable(),
    _ts_param$5(0, common.Inject(RESOLVED_ARTICLE_REPO)),
    _ts_param$5(1, common.Inject(RESOLVED_ARTICLE_VERSION_REPO)),
    _ts_metadata$5("design:type", Function),
    _ts_metadata$5("design:paramtypes", [
        typeof typeorm.Repository === "undefined" ? Object : typeorm.Repository,
        typeof typeorm.Repository === "undefined" ? Object : typeorm.Repository,
        typeof SignatureService === "undefined" ? Object : SignatureService
    ])
], ArticleDataLoader);

function _ts_decorate$5(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function _ts_metadata$4(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
function _ts_param$4(paramIndex, decorator) {
    return function(target, key) {
        decorator(target, key, paramIndex);
    };
}
class ArticleBaseService {
    baseArticleRepo;
    baseArticleVersionRepo;
    baseArticleVersionContentRepo;
    baseCategoryRepo;
    multipleLanguageMode;
    fullTextSearchMode;
    draftMode;
    signatureLevels;
    signatureLevelRepo;
    articleSignatureRepo;
    autoReleaseAfterApproved;
    dataSource;
    articleDataLoader;
    signatureService;
    constructor(baseArticleRepo, baseArticleVersionRepo, baseArticleVersionContentRepo, baseCategoryRepo, multipleLanguageMode, fullTextSearchMode, draftMode, signatureLevels, signatureLevelRepo, articleSignatureRepo, autoReleaseAfterApproved, dataSource, articleDataLoader, signatureService){
        this.baseArticleRepo = baseArticleRepo;
        this.baseArticleVersionRepo = baseArticleVersionRepo;
        this.baseArticleVersionContentRepo = baseArticleVersionContentRepo;
        this.baseCategoryRepo = baseCategoryRepo;
        this.multipleLanguageMode = multipleLanguageMode;
        this.fullTextSearchMode = fullTextSearchMode;
        this.draftMode = draftMode;
        this.signatureLevels = signatureLevels;
        this.signatureLevelRepo = signatureLevelRepo;
        this.articleSignatureRepo = articleSignatureRepo;
        this.autoReleaseAfterApproved = autoReleaseAfterApproved;
        this.dataSource = dataSource;
        this.articleDataLoader = articleDataLoader;
        this.signatureService = signatureService;
    }
    logger = new common.Logger(ArticleBaseService.name);
    queryStagesFeaturesCheck = (stage)=>{
        switch(stage){
            case ArticleStage.DRAFT:
                if (!this.draftMode) {
                    throw new Error('Draft mode is disabled.');
                }
                break;
            case ArticleStage.VERIFIED:
            case ArticleStage.REVIEWING:
                if (!this.signatureService.signatureEnabled) {
                    throw new Error('Signature mode is disabled.');
                }
                break;
        }
    };
    limitStageWithQueryBuilder(qb, stage, signatureLevel) {
        switch(stage){
            case ArticleStage.DRAFT:
                qb.innerJoin((subQb)=>{
                    subQb.from(this.baseArticleVersionRepo.metadata.tableName, 'versions');
                    subQb.select('versions.articleId', 'articleId');
                    subQb.addSelect('versions.version', 'version');
                    subQb.addSelect('ROW_NUMBER() OVER (PARTITION BY versions."articleId" ORDER BY versions."createdAt" DESC)', 'rowIndex');
                    subQb.andWhere('versions.releasedAt IS NULL');
                    subQb.andWhere('versions.submittedAt IS NULL');
                    return subQb;
                }, 'stage_ranked', 'stage_ranked."articleId" = versions."articleId" AND stage_ranked."version" = versions."version" AND stage_ranked."rowIndex" = 1');
                break;
            case ArticleStage.REVIEWING:
                qb.andWhere(`versions.releasedAt IS NULL`);
                qb.andWhere(`versions.submittedAt IS NOT NULL`);
                qb.leftJoin('versions.signatures', 'signatures', `signatures.result = :result`, {
                    result: ArticleSignatureResult.APPROVED
                });
                qb.leftJoin('signatures.signatureLevel', 'signatureLevel', 'signatureLevel.name = :signatureLevel', {
                    signatureLevel: signatureLevel ?? this.signatureService.finalSignatureLevel?.name
                });
                qb.andWhere('signatureLevel.id IS NULL');
                break;
            case ArticleStage.VERIFIED:
                qb.andWhere(`versions.releasedAt IS NULL`);
                qb.innerJoin((subQb)=>{
                    subQb.from(this.articleSignatureRepo.metadata.tableName, 'signatures');
                    subQb.innerJoin('signatures.articleVersion', 'articleVersion');
                    subQb.select('signatures.articleId', 'articleId');
                    subQb.addSelect('signatures.version', 'version');
                    subQb.addSelect('ROW_NUMBER() OVER (PARTITION BY signatures."articleId" ORDER BY signatures."signedAt" DESC)', 'rowIndex');
                    subQb.andWhere(`signatures.result = :result AND signatures."signatureLevelId" = :signatureLevelId`, {
                        result: ArticleSignatureResult.APPROVED,
                        signatureLevelId: this.signatureService.finalSignatureLevel?.id
                    });
                    return subQb;
                }, 'stage_ranked', 'stage_ranked."articleId" = versions."articleId" AND stage_ranked."version" = versions."version" AND stage_ranked."rowIndex" = 1');
                break;
            case ArticleStage.SCHEDULED:
                qb.innerJoin((subQb)=>{
                    subQb.from(this.baseArticleVersionRepo.metadata.tableName, 'versions');
                    subQb.select('versions.articleId', 'articleId');
                    subQb.addSelect('versions.version', 'version');
                    subQb.addSelect('ROW_NUMBER() OVER (PARTITION BY versions."articleId" ORDER BY versions."releasedAt" ASC)', 'rowIndex');
                    subQb.andWhere(`versions.releasedAt IS NOT NULL`);
                    subQb.andWhere(`versions.releasedAt > CURRENT_TIMESTAMP`);
                    return subQb;
                }, 'stage_ranked', 'stage_ranked."articleId" = versions."articleId" AND stage_ranked."version" = versions."version" AND stage_ranked."rowIndex" = 1');
                break;
            case ArticleStage.RELEASED:
            default:
                qb.innerJoin((subQb)=>{
                    subQb.from(this.baseArticleVersionRepo.metadata.tableName, 'versions');
                    subQb.select('versions.articleId', 'articleId');
                    subQb.addSelect('versions.version', 'version');
                    subQb.addSelect('ROW_NUMBER() OVER (PARTITION BY versions."articleId" ORDER BY versions."releasedAt" DESC)', 'rowIndex');
                    subQb.andWhere(`versions.releasedAt IS NOT NULL`);
                    subQb.andWhere(`versions.releasedAt <= CURRENT_TIMESTAMP`);
                    return subQb;
                }, 'stage_ranked', 'stage_ranked."articleId" = versions."articleId" AND stage_ranked."version" = versions."version" AND stage_ranked."rowIndex" = 1');
                break;
        }
        return qb;
    }
    getDefaultQueryBuilder(alias = 'articles', options, runner) {
        if (options?.version && options?.stage) {
            this.logger.warn(`Combining version and stage filters, only version filter will be applied.`);
        }
        if (options?.stage) {
            this.queryStagesFeaturesCheck(options.stage);
        }
        const qb = runner ? runner.manager.createQueryBuilder(this.baseArticleRepo.metadata.tableName, alias) : this.baseArticleRepo.createQueryBuilder(alias);
        qb.leftJoinAndSelect(`${alias}.categories`, 'categories');
        qb.innerJoinAndSelect(`${alias}.versions`, 'versions');
        qb.innerJoinAndSelect('versions.multiLanguageContents', 'multiLanguageContents');
        if (options?.version !== undefined) {
            qb.andWhere('versions.version = :version', {
                version: options.version
            });
        } else if (options?.stage) {
            this.limitStageWithQueryBuilder(qb, options.stage, (options.stage === ArticleStage.REVIEWING ? options?