@comet/cms-api 9.0.0-beta.1 → 9.0.0-beta.3

package/lib/page-tree/page-tree.service.js

@@ -11,26 +11,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageTreeService = void 0;
 const nestjs_1 = require("@mikro-orm/nestjs");
@@ -50,313 +30,296 @@ let PageTreeService = class PageTreeService {
         this.redirectsService = redirectsService;
         this.config = config;
     }
-    createNode(input, category, scope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: check for unique id
-            const readApi = this.createReadApi({ visibility: "all" });
-            if (input.id && input.parentId && input.id === input.parentId) {
-                throw new validation_exception_1.CometValidationException("A page cannot be its own parent");
-            }
-            const path = yield this.pathForParentAndSlug(input.parentId || null, input.slug);
-            if (this.config.reservedPaths.includes(path)) {
-                throw new validation_exception_1.CometValidationException("Reserved path");
-            }
-            const nodeWithSamePath = yield this.nodeWithSamePath(path, scope);
-            if (nodeWithSamePath) {
-                throw new validation_exception_1.CometValidationException("Slug leads to duplicate path");
-            }
-            const { attachedDocument: attachedDocumentInput, parentId } = input, restInput = __rest(input, ["attachedDocument", "parentId"]);
-            const siblingNodeWithHighestPosition = yield this.pageTreeRepository
-                .createQueryBuilder()
-                .where({
-                parentId: parentId !== null && parentId !== void 0 ? parentId : null,
-                scope,
-            })
-                .orderBy({ pos: "DESC" })
-                .getSingleResult();
-            // insert newly created nodes at the last position
-            const pos = siblingNodeWithHighestPosition ? siblingNodeWithHighestPosition.pos + 1 : 1;
-            const parent = parentId ? yield this.pageTreeRepository.findOneOrFail(parentId) : undefined;
-            const newNode = this.pageTreeRepository.create(Object.assign(Object.assign({}, restInput), { parent,
-                parentId,
-                pos, visibility: input.slug === "home" ? types_1.PageTreeNodeVisibility.Published : types_1.PageTreeNodeVisibility.Unpublished, scope,
-                category, documentType: attachedDocumentInput.type }));
-            yield this.entityManager.persistAndFlush(newNode);
-            if (attachedDocumentInput.id) {
-                yield this.entityManager.persistAndFlush(this.attachedDocumentsRepository.create({
-                    pageTreeNodeId: newNode.id,
-                    type: attachedDocumentInput.type,
-                    documentId: attachedDocumentInput.id,
-                }));
-            }
-            return readApi.getNodeOrFail(newNode.id);
+    async createNode(input, category, scope) {
+        // TODO: check for unique id
+        const readApi = this.createReadApi({ visibility: "all" });
+        if (input.id && input.parentId && input.id === input.parentId) {
+            throw new validation_exception_1.CometValidationException("A page cannot be its own parent");
+        }
+        const path = await this.pathForParentAndSlug(input.parentId || null, input.slug);
+        if (this.config.reservedPaths.includes(path)) {
+            throw new validation_exception_1.CometValidationException("Reserved path");
+        }
+        const nodeWithSamePath = await this.nodeWithSamePath(path, scope);
+        if (nodeWithSamePath) {
+            throw new validation_exception_1.CometValidationException("Slug leads to duplicate path");
+        }
+        const { attachedDocument: attachedDocumentInput, parentId, ...restInput } = input;
+        const siblingNodeWithHighestPosition = await this.pageTreeRepository
+            .createQueryBuilder()
+            .where({
+            parentId: parentId ?? null,
+            scope,
+        })
+            .orderBy({ pos: "DESC" })
+            .getSingleResult();
+        // insert newly created nodes at the last position
+        const pos = siblingNodeWithHighestPosition ? siblingNodeWithHighestPosition.pos + 1 : 1;
+        const parent = parentId ? await this.pageTreeRepository.findOneOrFail(parentId) : undefined;
+        const newNode = this.pageTreeRepository.create({
+            ...restInput,
+            parent,
+            parentId,
+            pos,
+            visibility: input.slug === "home" ? types_1.PageTreeNodeVisibility.Published : types_1.PageTreeNodeVisibility.Unpublished,
+            scope,
+            category,
+            documentType: attachedDocumentInput.type,
         });
+        await this.entityManager.persistAndFlush(newNode);
+        if (attachedDocumentInput.id) {
+            await this.entityManager.persistAndFlush(this.attachedDocumentsRepository.create({
+                pageTreeNodeId: newNode.id,
+                type: attachedDocumentInput.type,
+                documentId: attachedDocumentInput.id,
+            }));
+        }
+        return readApi.getNodeOrFail(newNode.id);
     }
-    updateNode(id, input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const readApi = this.createReadApi({ visibility: "all" });
-            const existingNode = yield readApi.getNodeOrFail(id);
-            if (!existingNode)
-                throw new Error("Can't find page-tree-node with id");
-            if (existingNode.slug === "home" && input.slug !== "home") {
-                throw new Error(`Slug of page "home" cannot be changed`);
-            }
-            if (input.createAutomaticRedirectsOnSlugChange && existingNode.slug != input.slug) {
-                yield this.redirectsService.createAutomaticRedirects(existingNode);
-            }
-            const existingNodePath = yield readApi.nodePath(existingNode);
-            const newPath = this.newPathForSlug(existingNodePath, input.slug);
-            if (this.config.reservedPaths.includes(newPath)) {
-                throw new validation_exception_1.CometValidationException("Reserved path");
-            }
-            const nodeWithSamePath = yield this.nodeWithSamePath(newPath, existingNode.scope);
-            if (nodeWithSamePath && nodeWithSamePath.id !== id) {
-                throw new validation_exception_1.CometValidationException("Slug leads to duplicate path");
-            }
-            const { attachedDocument: attachedDocumentInput, createAutomaticRedirectsOnSlugChange } = input, restInput = __rest(input, ["attachedDocument", "createAutomaticRedirectsOnSlugChange"]);
-            existingNode.assign(restInput);
-            if (attachedDocumentInput) {
-                existingNode.assign({ documentType: attachedDocumentInput.type });
-                // check if attached document exists
-                if (attachedDocumentInput.id) {
-                    const document = yield this.resolveDocument(attachedDocumentInput.type, attachedDocumentInput.id);
-                    if (!document) {
-                        throw new Error(`The assigned document does not exist or is not of type ${attachedDocumentInput.type}`);
-                    }
-                    // check if document is already attached and attach if not
-                    const attachedDocument = yield this.attachedDocumentsRepository.findOne({ pageTreeNodeId: id, documentId: attachedDocumentInput.id });
-                    if (!attachedDocument) {
-                        this.entityManager.persist(this.attachedDocumentsRepository.create({
-                            pageTreeNodeId: id,
-                            type: attachedDocumentInput.type,
-                            documentId: attachedDocumentInput.id,
-                        }));
-                    }
+    async updateNode(id, input) {
+        const readApi = this.createReadApi({ visibility: "all" });
+        const existingNode = await readApi.getNodeOrFail(id);
+        if (!existingNode) {
+            throw new Error("Can't find page-tree-node with id");
+        }
+        if (existingNode.slug === "home" && input.slug !== "home") {
+            throw new Error(`Slug of page "home" cannot be changed`);
+        }
+        if (input.createAutomaticRedirectsOnSlugChange && existingNode.slug != input.slug) {
+            await this.redirectsService.createAutomaticRedirects(existingNode);
+        }
+        const existingNodePath = await readApi.nodePath(existingNode);
+        const newPath = this.newPathForSlug(existingNodePath, input.slug);
+        if (this.config.reservedPaths.includes(newPath)) {
+            throw new validation_exception_1.CometValidationException("Reserved path");
+        }
+        const nodeWithSamePath = await this.nodeWithSamePath(newPath, existingNode.scope);
+        if (nodeWithSamePath && nodeWithSamePath.id !== id) {
+            throw new validation_exception_1.CometValidationException("Slug leads to duplicate path");
+        }
+        const { attachedDocument: attachedDocumentInput, createAutomaticRedirectsOnSlugChange, ...restInput } = input;
+        existingNode.assign(restInput);
+        if (attachedDocumentInput) {
+            existingNode.assign({ documentType: attachedDocumentInput.type });
+            // check if attached document exists
+            if (attachedDocumentInput.id) {
+                const document = await this.resolveDocument(attachedDocumentInput.type, attachedDocumentInput.id);
+                if (!document) {
+                    throw new Error(`The assigned document does not exist or is not of type ${attachedDocumentInput.type}`);
                 }
-            }
-            yield this.entityManager.flush();
-            return readApi.getNodeOrFail(id); // refresh data
-        });
-    }
-    updateNodeVisibility(id, newVisibility) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const node = yield this.createReadApi({ visibility: "all" }).getNodeOrFail(id);
-            if (node.slug === "home" && newVisibility !== types_1.PageTreeNodeVisibility.Published) {
-                throw new Error(`Page "home" cannot be ${newVisibility.toLowerCase()}`);
-            }
-            let changedSlug = undefined;
-            if (node.visibility === types_1.PageTreeNodeVisibility.Archived && newVisibility !== types_1.PageTreeNodeVisibility.Archived) {
-                const readApi = this.createReadApi({ visibility: "all" });
-                const existingNodePath = yield readApi.nodePath(node);
-                const slug = node.slug;
-                let slugIncrement = 0;
-                while (true) {
-                    const nextSlugToTest = slugIncrement ? `${slug}-${slugIncrement}` : slug;
-                    const newPath = this.newPathForSlug(existingNodePath, nextSlugToTest);
-                    const nodeWithSamePath = yield this.nodeWithSamePath(newPath, node.scope);
-                    if (!nodeWithSamePath) {
-                        break;
-                    }
-                    slugIncrement++;
+                // check if document is already attached and attach if not
+                const attachedDocument = await this.attachedDocumentsRepository.findOne({ pageTreeNodeId: id, documentId: attachedDocumentInput.id });
+                if (!attachedDocument) {
+                    this.entityManager.persist(this.attachedDocumentsRepository.create({
+                        pageTreeNodeId: id,
+                        type: attachedDocumentInput.type,
+                        documentId: attachedDocumentInput.id,
+                    }));
                 }
-                changedSlug = slugIncrement ? `${slug}-${slugIncrement}` : slug;
             }
-            node.assign({ visibility: newVisibility, slug: changedSlug !== null && changedSlug !== void 0 ? changedSlug : node.slug });
-            // TODO flush shouldn't happen here, remove in a major version
-            yield this.entityManager.flush();
-        });
+        }
+        await this.entityManager.flush();
+        return readApi.getNodeOrFail(id); // refresh data
     }
-    updateNodePosition(id, input) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async updateNodeVisibility(id, newVisibility) {
+        const node = await this.createReadApi({ visibility: "all" }).getNodeOrFail(id);
+        if (node.slug === "home" && newVisibility !== types_1.PageTreeNodeVisibility.Published) {
+            throw new Error(`Page "home" cannot be ${newVisibility.toLowerCase()}`);
+        }
+        let changedSlug = undefined;
+        if (node.visibility === types_1.PageTreeNodeVisibility.Archived && newVisibility !== types_1.PageTreeNodeVisibility.Archived) {
             const readApi = this.createReadApi({ visibility: "all" });
-            const existingNode = yield readApi.getNodeOrFail(id);
-            if (!existingNode)
-                throw new Error("Can't find page-tree-node with id");
-            if (input.parentId) {
-                let currentParentId = input.parentId;
-                while (currentParentId !== null) {
-                    if (currentParentId === id) {
-                        throw new validation_exception_1.CometValidationException("A page cannot be its own parent or be moved under one of its descendants");
-                    }
-                    const parentNode = yield readApi.getNode(currentParentId);
-                    if (!parentNode)
-                        break;
-                    currentParentId = parentNode.parentId;
+            const existingNodePath = await readApi.nodePath(node);
+            const slug = node.slug;
+            let slugIncrement = 0;
+            while (true) {
+                const nextSlugToTest = slugIncrement ? `${slug}-${slugIncrement}` : slug;
+                const newPath = this.newPathForSlug(existingNodePath, nextSlugToTest);
+                const nodeWithSamePath = await this.nodeWithSamePath(newPath, node.scope);
+                if (!nodeWithSamePath) {
+                    break;
                 }
+                slugIncrement++;
             }
-            const requestedPath = yield this.pathForParentAndSlug(input.parentId, existingNode.slug);
-            if (this.config.reservedPaths.includes(requestedPath)) {
-                throw new validation_exception_1.CometValidationException("Reserved path");
-            }
-            let newSlug;
-            const nodeWithSamePath = yield this.nodeWithSamePath(requestedPath, existingNode.scope);
-            if (nodeWithSamePath && nodeWithSamePath.id !== existingNode.id) {
-                newSlug = yield this.findNextAvailableSlug(existingNode.slug, input.parentId, existingNode.scope);
-            }
-            const parentId = input.parentId;
-            if (input.pos !== existingNode.pos || input.parentId !== existingNode.parentId) {
-                const parent = parentId ? yield this.pageTreeRepository.findOneOrFail(parentId) : null;
-                yield this.entityManager.persistAndFlush(existingNode.assign({ parent, parentId, pos: input.pos, slug: newSlug !== null && newSlug !== void 0 ? newSlug : existingNode.slug }));
-                const qb = this.pageTreeRepository
-                    .createQueryBuilder()
-                    .select(["id", "pos"])
-                    .where({
-                    pos: { $gte: input.pos },
-                    id: { $ne: id },
-                    parentId,
-                });
-                if (parentId) {
-                    qb.andWhere({ parentId });
+            changedSlug = slugIncrement ? `${slug}-${slugIncrement}` : slug;
+        }
+        node.assign({ visibility: newVisibility, slug: changedSlug ?? node.slug });
+        // TODO flush shouldn't happen here, remove in a major version
+        await this.entityManager.flush();
+    }
+    async updateNodePosition(id, input) {
+        const readApi = this.createReadApi({ visibility: "all" });
+        const existingNode = await readApi.getNodeOrFail(id);
+        if (!existingNode) {
+            throw new Error("Can't find page-tree-node with id");
+        }
+        if (input.parentId) {
+            let currentParentId = input.parentId;
+            while (currentParentId !== null) {
+                if (currentParentId === id) {
+                    throw new validation_exception_1.CometValidationException("A page cannot be its own parent or be moved under one of its descendants");
                 }
-                if (existingNode.scope) {
-                    qb.andWhere({ scope: existingNode.scope });
+                const parentNode = await readApi.getNode(currentParentId);
+                if (!parentNode) {
+                    break;
                 }
-                const nodesToIncrement = yield qb.getResultList();
-                yield this.entityManager.persistAndFlush(nodesToIncrement.map((c) => c.assign({ pos: c.pos + 1 })));
+                currentParentId = parentNode.parentId;
             }
-            return readApi.getNodeOrFail(existingNode.id);
-        });
-    }
-    updateNodeSlug(id, slug) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pageTreeReadApi = this.createReadApi({
-                visibility: "all",
+        }
+        const requestedPath = await this.pathForParentAndSlug(input.parentId, existingNode.slug);
+        if (this.config.reservedPaths.includes(requestedPath)) {
+            throw new validation_exception_1.CometValidationException("Reserved path");
+        }
+        let newSlug;
+        const nodeWithSamePath = await this.nodeWithSamePath(requestedPath, existingNode.scope);
+        if (nodeWithSamePath && nodeWithSamePath.id !== existingNode.id) {
+            newSlug = await this.findNextAvailableSlug(existingNode.slug, input.parentId, existingNode.scope);
+        }
+        const parentId = input.parentId;
+        if (input.pos !== existingNode.pos || input.parentId !== existingNode.parentId) {
+            const parent = parentId ? await this.pageTreeRepository.findOneOrFail(parentId) : null;
+            await this.entityManager.persistAndFlush(existingNode.assign({ parent, parentId, pos: input.pos, slug: newSlug ?? existingNode.slug }));
+            const qb = this.pageTreeRepository
+                .createQueryBuilder()
+                .select(["id", "pos"])
+                .where({
+                pos: { $gte: input.pos },
+                id: { $ne: id },
+                parentId,
             });
-            const node = yield pageTreeReadApi.getNodeOrFail(id);
-            if (node.slug === "home" && slug !== "home") {
-                throw new Error(`Slug of page "home" cannot be changed`);
+            if (parentId) {
+                qb.andWhere({ parentId });
             }
-            const requestedPath = yield this.pathForParentAndSlug(node.parentId, slug);
-            const nodeWithSamePath = yield this.nodeWithSamePath(requestedPath, node.scope);
-            if (nodeWithSamePath && nodeWithSamePath.id !== node.id) {
-                throw new Error("Requested slug is already taken");
+            if (existingNode.scope) {
+                qb.andWhere({ scope: existingNode.scope });
             }
-            yield this.entityManager.persistAndFlush(node.assign({ slug: slug }));
-            return pageTreeReadApi.getNodeOrFail(id);
-        });
+            const nodesToIncrement = await qb.getResultList();
+            await this.entityManager.persistAndFlush(nodesToIncrement.map((c) => c.assign({ pos: c.pos + 1 })));
+        }
+        return readApi.getNodeOrFail(existingNode.id);
     }
-    updateCategory(id, category) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const readApi = this.createReadApi({ visibility: "all" });
-            const node = yield readApi.getNodeOrFail(id);
-            if (!node) {
-                throw new Error("Can't find page-tree-node with id");
-            }
-            const descendants = yield readApi.getDescendants(node);
-            yield this.pageTreeRepository
-                .createQueryBuilder()
-                .update({ category })
-                .where({ id: { $in: descendants.map((node) => node.id) } })
-                .execute();
-            const rootNodes = yield readApi.pageTreeRootNodeList({ category, scope: node.scope });
-            // 0 is added to avoid negative infinity for empty array
-            const lastPosition = Math.max(0, ...rootNodes.map((node) => node.pos)) + 1;
-            yield this.entityManager.persistAndFlush(node.assign({ category, parent: null, parentId: null, pos: lastPosition }));
+    async updateNodeSlug(id, slug) {
+        const pageTreeReadApi = this.createReadApi({
+            visibility: "all",
         });
+        const node = await pageTreeReadApi.getNodeOrFail(id);
+        if (node.slug === "home" && slug !== "home") {
+            throw new Error(`Slug of page "home" cannot be changed`);
+        }
+        const requestedPath = await this.pathForParentAndSlug(node.parentId, slug);
+        const nodeWithSamePath = await this.nodeWithSamePath(requestedPath, node.scope);
+        if (nodeWithSamePath && nodeWithSamePath.id !== node.id) {
+            throw new Error("Requested slug is already taken");
+        }
+        await this.entityManager.persistAndFlush(node.assign({ slug: slug }));
+        return pageTreeReadApi.getNodeOrFail(id);
     }
-    delete(pageTreeNode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (pageTreeNode.slug === "home") {
-                throw new Error(`Page "home" cannot be deleted`);
-            }
-            const readApi = this.createReadApi();
-            const childNodes = yield readApi.getChildNodes(pageTreeNode);
-            // recursively delete all child nodes
-            for (const childNode of childNodes) {
-                yield this.delete(childNode);
-            }
-            // 1. Delete all attached documents
-            const attachedDocuments = yield this.attachedDocumentsRepository.find({ pageTreeNodeId: pageTreeNode.id });
-            for (const attachedDocument of attachedDocuments) {
-                if (attachedDocument.id) {
-                    try {
-                        const repository = this.entityManager.getRepository(attachedDocument.type);
-                        const document = yield repository.findOneOrFail(attachedDocument.documentId);
-                        yield this.entityManager.removeAndFlush(document);
-                        yield this.entityManager.removeAndFlush(attachedDocument);
-                    }
-                    catch (_a) {
-                        throw new Error(`documentType ${attachedDocument.type} and documentId ${attachedDocument.id} cannot resolve`);
-                    }
+    async updateCategory(id, category) {
+        const readApi = this.createReadApi({ visibility: "all" });
+        const node = await readApi.getNodeOrFail(id);
+        if (!node) {
+            throw new Error("Can't find page-tree-node with id");
+        }
+        const descendants = await readApi.getDescendants(node);
+        await this.pageTreeRepository
+            .createQueryBuilder()
+            .update({ category })
+            .where({ id: { $in: descendants.map((node) => node.id) } })
+            .execute();
+        const rootNodes = await readApi.pageTreeRootNodeList({ category, scope: node.scope });
+        // 0 is added to avoid negative infinity for empty array
+        const lastPosition = Math.max(0, ...rootNodes.map((node) => node.pos)) + 1;
+        await this.entityManager.persistAndFlush(node.assign({ category, parent: null, parentId: null, pos: lastPosition }));
+    }
+    async delete(pageTreeNode) {
+        if (pageTreeNode.slug === "home") {
+            throw new Error(`Page "home" cannot be deleted`);
+        }
+        const readApi = this.createReadApi();
+        const childNodes = await readApi.getChildNodes(pageTreeNode);
+        // recursively delete all child nodes
+        for (const childNode of childNodes) {
+            await this.delete(childNode);
+        }
+        // 1. Delete all attached documents
+        const attachedDocuments = await this.attachedDocumentsRepository.find({ pageTreeNodeId: pageTreeNode.id });
+        for (const attachedDocument of attachedDocuments) {
+            if (attachedDocument.id) {
+                try {
+                    const repository = this.entityManager.getRepository(attachedDocument.type);
+                    const document = await repository.findOneOrFail(attachedDocument.documentId);
+                    await this.entityManager.removeAndFlush(document);
+                    await this.entityManager.removeAndFlush(attachedDocument);
+                }
+                catch {
+                    throw new Error(`documentType ${attachedDocument.type} and documentId ${attachedDocument.id} cannot resolve`);
                 }
             }
-            // 2. Delete page tree node itself
-            try {
-                yield this.entityManager.removeAndFlush(pageTreeNode);
-                return true;
-            }
-            catch (_b) {
-                return false;
-            }
-        });
+        }
+        // 2. Delete page tree node itself
+        try {
+            await this.entityManager.removeAndFlush(pageTreeNode);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    resolveDocument(documentType, documentId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const repository = this.entityManager.getRepository(documentType);
-                const document = yield repository.findOne(documentId);
-                return document !== null && document !== void 0 ? document : null;
-            }
-            catch (_a) {
-                throw new Error(`documentType ${documentType} and documentId ${documentId} cannot resolve`);
-            }
-        });
+    async resolveDocument(documentType, documentId) {
+        try {
+            const repository = this.entityManager.getRepository(documentType);
+            const document = await repository.findOne(documentId);
+            return document ?? null;
+        }
+        catch {
+            throw new Error(`documentType ${documentType} and documentId ${documentId} cannot resolve`);
+        }
     }
-    getAttachedDocuments(pageTreeNodeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.attachedDocumentsRepository.find({ pageTreeNodeId: pageTreeNodeId });
-        });
+    async getAttachedDocuments(pageTreeNodeId) {
+        return this.attachedDocumentsRepository.find({ pageTreeNodeId: pageTreeNodeId });
     }
-    getActiveAttachedDocument(pageTreeNodeId, activeType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const node = yield this.pageTreeRepository.findOneOrFail(pageTreeNodeId);
-            if (node.documentType !== activeType) {
-                return null;
-            }
-            const activeDocument = yield this.attachedDocumentsRepository.findOne({ pageTreeNodeId: pageTreeNodeId, type: activeType });
-            if (!activeDocument) {
-                return null;
-            }
-            return activeDocument;
-        });
+    async getActiveAttachedDocument(pageTreeNodeId, activeType) {
+        const node = await this.pageTreeRepository.findOneOrFail(pageTreeNodeId);
+        if (node.documentType !== activeType) {
+            return null;
+        }
+        const activeDocument = await this.attachedDocumentsRepository.findOne({ pageTreeNodeId: pageTreeNodeId, type: activeType });
+        if (!activeDocument) {
+            return null;
+        }
+        return activeDocument;
     }
-    attachDocument(attachedDocumentInput, pageTreeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const node = yield this.pageTreeRepository.findOne(pageTreeId);
-            if (!node) {
-                throw new Error(`Can't find page-tree-node with id ${pageTreeId}`);
-            }
-            const resolvedDocument = yield this.resolveDocument(attachedDocumentInput.type, attachedDocumentInput.id);
-            if (!resolvedDocument) {
-                throw new Error(`The assigned document does not exist or is not of type ${attachedDocumentInput.type}`);
-            }
-            // check if document is already attached and attach if not
-            const attachedDocument = yield this.attachedDocumentsRepository.findOne({ pageTreeNodeId: node.id, documentId: attachedDocumentInput.id });
-            if (!attachedDocument) {
-                this.entityManager.persist(this.attachedDocumentsRepository.create({
-                    pageTreeNodeId: node.id,
-                    type: attachedDocumentInput.type,
-                    documentId: attachedDocumentInput.id,
-                }));
-            }
-        });
+    async attachDocument(attachedDocumentInput, pageTreeId) {
+        const node = await this.pageTreeRepository.findOne(pageTreeId);
+        if (!node) {
+            throw new Error(`Can't find page-tree-node with id ${pageTreeId}`);
+        }
+        const resolvedDocument = await this.resolveDocument(attachedDocumentInput.type, attachedDocumentInput.id);
+        if (!resolvedDocument) {
+            throw new Error(`The assigned document does not exist or is not of type ${attachedDocumentInput.type}`);
+        }
+        // check if document is already attached and attach if not
+        const attachedDocument = await this.attachedDocumentsRepository.findOne({ pageTreeNodeId: node.id, documentId: attachedDocumentInput.id });
+        if (!attachedDocument) {
+            this.entityManager.persist(this.attachedDocumentsRepository.create({
+                pageTreeNodeId: node.id,
+                type: attachedDocumentInput.type,
+                documentId: attachedDocumentInput.id,
+            }));
+        }
     }
-    pathForParentAndSlug(parentId, slug) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const readApi = this.createReadApi({ visibility: "all" });
-            let parentPath = parentId ? yield readApi.nodePathById(parentId) : "";
-            if (parentPath === "/") {
-                parentPath = "/home";
-            }
-            return `${parentPath}/${slug}`;
-        });
+    async pathForParentAndSlug(parentId, slug) {
+        const readApi = this.createReadApi({ visibility: "all" });
+        let parentPath = parentId ? await readApi.nodePathById(parentId) : "";
+        if (parentPath === "/") {
+            parentPath = "/home";
+        }
+        return `${parentPath}/${slug}`;
     }
-    nodeWithSamePath(path, scope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.createReadApi({ visibility: [types_1.PageTreeNodeVisibility.Published, types_1.PageTreeNodeVisibility.Unpublished] }).getNodeByPath(path, {
-                scope,
-            }); // Slugs of archived pages can be reused
-        });
+    async nodeWithSamePath(path, scope) {
+        return this.createReadApi({ visibility: [types_1.PageTreeNodeVisibility.Published, types_1.PageTreeNodeVisibility.Unpublished] }).getNodeByPath(path, {
+            scope,
+        }); // Slugs of archived pages can be reused
     }
     createReadApi(options = {}) {
         return (0, page_tree_read_api_1.createReadApi)({
@@ -369,17 +332,15 @@ let PageTreeService = class PageTreeService {
         const newPath = `${parentPath || ""}/${slug}`;
         return newPath;
     }
-    findNextAvailableSlug(slug_1) {
-        return __awaiter(this, arguments, void 0, function* (slug, parentId = null, scope) {
-            let counter = 1;
-            let newSlug, newPath;
-            do {
-                newSlug = `${slug}-${counter}`;
-                newPath = yield this.pathForParentAndSlug(parentId, newSlug);
-                counter++;
-            } while (yield this.nodeWithSamePath(newPath, scope));
-            return newSlug;
-        });
+    async findNextAvailableSlug(slug, parentId = null, scope) {
+        let counter = 1;
+        let newSlug, newPath;
+        do {
+            newSlug = `${slug}-${counter}`;
+            newPath = await this.pathForParentAndSlug(parentId, newSlug);
+            counter++;
+        } while (await this.nodeWithSamePath(newPath, scope));
+        return newSlug;
     }
 };
 exports.PageTreeService = PageTreeService;