@dosgato/api 1.2.4 → 1.3.1

package/dist/page/page.service.js

@@ -2,7 +2,7 @@ import { BaseService, ValidatedResponse, MutationMessageType } from '@txstate-mw
 import { ManyJoinedLoader, OneToManyLoader, PrimaryKeyLoader } from 'dataloader-factory';
 import db from 'mysql2-async/db';
 import { equal, filterAsync, get, intersect, isBlank, isNotBlank, isNotNull, keyby, set, someAsync, sortby, stringify, unique } from 'txstate-utils';
-import { VersionedService, templateRegistry, DosGatoService, PageResponse, PagesResponse, createPage, getPages, movePages, deletePages, renamePage, TemplateService, getPageIndexes, undeletePages, validatePage, copyPages, TemplateType, migratePage, PagetreeServiceInternal, collectTemplates, TemplateServiceInternal, SiteServiceInternal, PagetreeType, DeleteState, publishPageDeletions, getPagesByPath, parsePath, normalizePath, validateRecurse, DeleteStateAll, PageRuleService, SiteRuleService, shiftPath, systemContext, collectComponents, makePathSafe, LaunchState } from '../internal.js';
+import { VersionedService, templateRegistry, DosGatoService, PageResponse, PagesResponse, createPage, getPages, movePages, deletePages, renamePage, TemplateService, getPageIndexes, undeletePages, validatePage, copyPages, TemplateType, migratePage, PagetreeServiceInternal, collectTemplates, TemplateServiceInternal, SiteServiceInternal, PagetreeType, DeleteState, publishPageDeletions, getPagesByPath, parsePath, normalizePath, validateRecurse, DeleteStateAll, PageRuleService, SiteRuleService, systemContext, collectComponents, makePathSafe, LaunchState } from '../internal.js';
 const pagesByInternalIdLoader = new PrimaryKeyLoader({
     fetch: async (internalIds) => {
         return await getPages({ internalIds, deleteStates: DeleteStateAll });
@@ -110,9 +110,11 @@ export class PageServiceInternal extends BaseService {
             return page;
         return await this.findByInternalId(rootId);
     }
-    async getPath(page) {
-        const ancestors = await this.getPageAncestors(page);
-        return `/${ancestors.map(a => a.name).join('/')}${ancestors.length ? '/' : ''}${page.name}`;
+    /**
+     * @deprecated use page.resolvedPath instead
+     */
+    getPath(page) {
+        return page.resolvedPath;
     }
     async getData(page, version, published, toSchemaVersion = templateRegistry.currentSchemaVersion) {
         const [versioned, extras] = await Promise.all([
@@ -129,7 +131,7 @@ export class PageServiceInternal extends BaseService {
             siteId: String(page.siteInternalId),
             pagetreeId: page.pagetreeId,
             parentId: String(page.parentInternalId),
-            pagePath: await this.getPath(page),
+            pagePath: page.resolvedPath,
             pageId: page.id,
             linkId: page.linkId,
             name: page.name
@@ -231,83 +233,71 @@ export class PageService extends DosGatoService {
         super(...arguments);
         this.raw = this.svc(PageServiceInternal);
     }
-    async postFilter(pages, filter) {
-        return filter?.viewForEdit ? await filterAsync(pages, async (p) => await this.mayViewForEdit(p)) : pages;
+    postFilter(pages, filter) {
+        return filter?.viewForEdit ? pages.filter(p => this.mayViewForEdit(p)) : pages;
     }
     async find(filter) {
-        const [ret] = await Promise.all([
-            this.raw.find(filter),
-            this.currentPageRules() // pre-load and cache page rules so they're ready for removeUnauthorized
-        ]);
+        const ret = await this.raw.find(filter);
         if (filter.links?.length || filter.paths?.length || filter.ids?.length)
-            return await filterAsync(ret, async (p) => await this.mayViewIndividual(p));
-        return await this.postFilter(await this.removeUnauthorized(ret), filter);
+            return ret.filter(p => this.mayViewIndividual(p));
+        return this.postFilter(this.removeUnauthorized(ret), filter);
     }
     async findById(id) {
-        return await this.removeUnauthorized(await this.raw.findById(id));
+        return this.removeUnauthorized(await this.raw.findById(id));
     }
     async findByIds(ids) {
-        return await this.removeUnauthorized(await this.raw.findByIds(ids));
+        return this.removeUnauthorized(await this.raw.findByIds(ids));
     }
     async findByInternalId(internalId) {
-        return await this.removeUnauthorized(await this.raw.findByInternalId(internalId));
+        return this.removeUnauthorized(await this.raw.findByInternalId(internalId));
     }
     async findByPagetreeId(id, filter) {
-        const [ret] = await Promise.all([
-            this.raw.findByPagetreeId(id, filter),
-            this.currentPageRules() // pre-load and cache page rules so they're ready for removeUnauthorized
-        ]);
-        return await this.postFilter(await this.removeUnauthorized(ret), filter);
+        const ret = await this.raw.findByPagetreeId(id, filter);
+        return this.postFilter(this.removeUnauthorized(ret), filter);
     }
     async findByTemplate(key, filter) {
-        return await this.postFilter(await this.removeUnauthorized(await this.raw.findByTemplate(key, filter)), filter);
+        return this.postFilter(this.removeUnauthorized(await this.raw.findByTemplate(key, filter)), filter);
     }
     async getPageChildren(page, recursive, filter) {
-        return await this.postFilter(await this.removeUnauthorized(await this.raw.getPageChildren(page, recursive, filter)), filter);
+        return this.postFilter(this.removeUnauthorized(await this.raw.getPageChildren(page, recursive, filter)), filter);
     }
     async getPageAncestors(page) {
-        return await this.removeUnauthorized(await this.raw.getPageAncestors(page));
+        return this.removeUnauthorized(await this.raw.getPageAncestors(page));
     }
     async getApprovedTemplates(page, filter) {
         const templates = await this.svc(TemplateServiceInternal).find(filter);
         return await filterAsync(templates, async (template) => await this.svc(TemplateService).mayUseOnPage(template, page));
     }
     async getRootPage(page) {
-        return await this.removeUnauthorized(await this.raw.getRootPage(page));
+        return this.removeUnauthorized(await this.raw.getRootPage(page));
     }
-    async getPath(page) {
-        return await this.raw.getPath(page);
+    getPath(page) {
+        return this.raw.getPath(page);
     }
     async getTags(page, published) {
         return await this.svc(VersionedService).getCurrentIndexValues(page.intDataId, 'dg_tag', published);
     }
     async getData(page, version, published, toSchemaVersion = templateRegistry.currentSchemaVersion) {
-        if (!published && !await this.mayViewLatest(page))
+        if (!published && !this.mayViewLatest(page))
             throw new Error('User is only permitted to see the published version of this page.');
         return await this.raw.getData(page, version, published, toSchemaVersion);
     }
-    async hasPathBasedPageRulesForSite(siteId) {
+    hasPathBasedPageRulesForSite(siteId) {
         var _a;
         ;
         (_a = this.ctx).hasPathBasedPageRulesForSite ?? (_a.hasPathBasedPageRulesForSite = {});
         if (!this.ctx.hasPathBasedPageRulesForSite[siteId]) {
-            const rules = await this.currentPageRules();
+            const rules = this.ctx.authInfo.pageRules;
             this.ctx.hasPathBasedPageRulesForSite[siteId] = rules.some(r => r.path !== '/' && (!r.siteId || r.siteId === siteId));
         }
         return this.ctx.hasPathBasedPageRulesForSite[siteId];
     }
     // may view the page in a list
-    async mayView(page) {
+    mayView(page) {
         if (page.orphaned) {
-            const siteRules = (await this.currentSiteRules()).filter(r => SiteRuleService.applies(r, page.siteId));
-            return siteRules.some(r => r.grants.delete);
+            return this.ctx.authInfo.siteRules.some(r => r.grants.delete && SiteRuleService.applies(r, page.siteId));
         }
-        const [pageRules, pagePath] = await Promise.all([
-            this.currentPageRules(),
-            this.raw.getPath(page)
-        ]);
-        const pagePathWithoutSite = shiftPath(pagePath);
-        for (const pr of pageRules) {
+        for (const pr of this.ctx.authInfo.pageRules) {
             if (!pr.grants.view)
                 continue;
             if (!PageRuleService.appliesToPagetree(pr, page))
@@ -316,29 +306,30 @@ export class PageService extends DosGatoService {
                 continue;
             if (page.deleteState === DeleteState.MARKEDFORDELETE && !pr.grants.delete)
                 continue;
-            if (PageRuleService.appliesToPath(pr, pagePathWithoutSite))
+            if (PageRuleService.appliesToPath(pr, page.resolvedPathWithoutSitename))
                 return true;
-            if (PageRuleService.appliesToChildOfPath(pr, pagePathWithoutSite))
+            if (PageRuleService.appliesToChildOfPath(pr, page.resolvedPathWithoutSitename))
                 return true;
-            if (PageRuleService.appliesToParentOfPath(pr, pagePathWithoutSite))
+            if (PageRuleService.appliesToParentOfPath(pr, page.resolvedPathWithoutSitename))
                 return true;
         }
         return false;
     }
     // may view the page if requested individually
-    async mayViewIndividual(page) {
-        return (page.pagetreeType === PagetreeType.PRIMARY && !page.orphaned && page.deleteState === DeleteState.NOTDELETED) || await this.mayView(page);
+    mayViewIndividual(page) {
+        return (page.pagetreeType === PagetreeType.PRIMARY && !page.orphaned && page.deleteState === DeleteState.NOTDELETED) || this.mayView(page);
     }
-    async mayViewForEdit(page) {
-        return await this.mayView(page);
+    mayViewForEdit(page) {
+        return this.mayView(page);
     }
-    async mayViewLatest(page) {
-        return await this.havePagePerm(page, 'viewlatest');
+    mayViewLatest(page) {
+        return this.havePagePerm(page, 'viewlatest');
     }
-    async mayViewManagerUI() {
-        return (await this.currentPageRules()).some(r => r.grants.viewForEdit);
+    mayViewManagerUI() {
+        return this.ctx.authInfo.pageRules.some(r => r.grants.viewForEdit);
     }
-    async isPublished(page) {
+    /** @deprecated use page.published */
+    isPublished(page) {
         return page.published;
     }
     async isLive(page) {
@@ -355,10 +346,10 @@ export class PageService extends DosGatoService {
             return true;
         return page.orphaned;
     }
-    async checkPerm(page, perm, acceptPendingDelete) {
+    checkPerm(page, perm, acceptPendingDelete) {
         if (this.isOrphanedOrDeleted(page, acceptPendingDelete))
             return false;
-        return await this.havePagePerm(page, perm);
+        return this.havePagePerm(page, perm);
     }
     opRestricted(page, operation) {
         return templateRegistry.serverConfig.restrictPageOperation?.({
@@ -367,24 +358,23 @@ export class PageService extends DosGatoService {
             path: page.path,
             templateKey: page.templateKey,
             pagetreeType: page.pagetreeType
-        }, operation, this.currentRoles());
+        }, operation, this.ctx.authInfo.roles);
     }
     // authenticated user may create pages underneath given page
-    async mayCreate(page) {
-        return !this.opRestricted(page, 'into') && await this.checkPerm(page, 'create', false);
+    mayCreate(page) {
+        return !this.opRestricted(page, 'into') && this.checkPerm(page, 'create', false);
     }
-    async mayUpdate(page) {
-        return await this.checkPerm(page, 'update', false);
+    mayUpdate(page) {
+        return this.checkPerm(page, 'update', false);
     }
     async mayPublish(page, parentBeingPublished) {
-        if (!await this.checkPerm(page, 'publish', false))
+        if (!this.checkPerm(page, 'publish', false))
             return false;
         if (page.pagetreeType === PagetreeType.ARCHIVE)
             return false;
         if (page.parentInternalId && !parentBeingPublished) {
             const parent = await this.raw.findByInternalId(page.parentInternalId);
-            if (!await this.isPublished(parent))
-                return false;
+            return (!!parent.published);
         }
         return true;
     }
@@ -394,30 +384,26 @@ export class PageService extends DosGatoService {
             return false;
         if (this.opRestricted(page, 'unpublish'))
             return false;
-        const [checkPerm, isPublished] = await Promise.all([
-            this.checkPerm(page, 'unpublish', !!parentBeingUnpublished),
-            this.isPublished(page)
-        ]);
-        return checkPerm && (isPublished || !!parentBeingUnpublished);
+        return this.checkPerm(page, 'unpublish', !!parentBeingUnpublished) && (page.published || !!parentBeingUnpublished);
     }
-    async mayMove(page) {
+    mayMove(page) {
         if (!page.parentInternalId)
             return false; // root page of a site/pagetree cannot be moved
         if (this.opRestricted(page, 'move'))
             return false;
-        return await this.checkPerm(page, 'move', false);
+        return this.checkPerm(page, 'move', false);
     }
-    async mayDelete(page) {
+    mayDelete(page) {
         if (!page.parentInternalId)
             return false; // root page of a site/pagetree cannot be deleted
         if (this.opRestricted(page, 'delete'))
             return false;
-        return await this.checkPerm(page, 'delete', true);
+        return this.checkPerm(page, 'delete', true);
     }
-    async mayUndelete(page) {
+    mayUndelete(page) {
         if (page.deleteState === DeleteState.NOTDELETED || page.orphaned)
             return false;
-        return page.deleteState === DeleteState.MARKEDFORDELETE ? await this.havePagePerm(page, 'delete') : await this.havePagePerm(page, 'undelete');
+        return page.deleteState === DeleteState.MARKEDFORDELETE ? this.havePagePerm(page, 'delete') : this.havePagePerm(page, 'undelete');
     }
     /**
      * MUTATIONS
@@ -425,7 +411,7 @@ export class PageService extends DosGatoService {
     async movePages(dataIds, targetId, above) {
         const pages = (await Promise.all(dataIds.map(async (id) => await this.raw.findById(id)))).filter(isNotNull);
         const { parent, aboveTarget } = await this.resolveTarget(targetId, above);
-        if (!(await this.mayCreate(parent)) || (await someAsync(pages, async (page) => !(await this.mayMove(page))))) {
+        if (!this.mayCreate(parent) || pages.some(page => !this.mayMove(page))) {
             throw new Error('You are not permitted to perform this move.');
         }
         if (pages.some(p => p.pagetreeId !== parent.pagetreeId))
@@ -442,7 +428,7 @@ export class PageService extends DosGatoService {
         if (!pages.length)
             throw new Error('No valid pages selected.');
         const { parent, aboveTarget } = await this.resolveTarget(targetId, above);
-        if (!parent || !(await this.mayCreate(parent))) {
+        if (!parent || !(this.mayCreate(parent))) {
             throw new Error('You are not permitted to copy pages to this location.');
         }
         // Is this page allowed to be copied here?
@@ -510,7 +496,7 @@ export class PageService extends DosGatoService {
     }
     async createPage(name, data, targetId, above, validateOnly, extra) {
         const { parent, aboveTarget } = await this.resolveTarget(targetId, above);
-        if (!(await this.mayCreate(parent)))
+        if (!(this.mayCreate(parent)))
             throw new Error('Current user is not permitted to create pages in the specified parent.');
         // at the time of writing this comment, template usage is approved for an entire pagetree, so
         // it should be safe to simply check if the targeted parent/sibling is allowed to use this template
@@ -522,7 +508,7 @@ export class PageService extends DosGatoService {
             siteId: site.id,
             pagetreeId: pagetree.id,
             parentId: parent.id,
-            pagePath: `${await this.getPath(parent)}/${name}`,
+            pagePath: `${parent.resolvedPath}/${name}`,
             name
         };
         const migrated = await migratePage(data, extras);
@@ -546,7 +532,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot update a page that does not exist.');
-        if (!(await this.mayUpdate(page)))
+        if (!this.mayUpdate(page))
             throw new Error(`Current user is not permitted to update page ${String(page.name)}`);
         await this.validatePageTemplates(data, { page });
         const parent = page.parentInternalId ? await this.findByInternalId(page.parentInternalId) : undefined;
@@ -557,7 +543,7 @@ export class PageService extends DosGatoService {
             siteId: site.id,
             pagetreeId: pagetree.id,
             parentId: parent?.id,
-            pagePath: `${parent ? await this.getPath(parent) : ''}/${page.name}`,
+            pagePath: `${parent?.resolvedPath ?? ''}/${page.name}`,
             name: page.name,
             linkId: page.linkId,
             pageId: page.id
@@ -581,7 +567,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot restore an older version of a page that does not exist.');
-        if (!(await this.mayUpdate(page)))
+        if (!(this.mayUpdate(page)))
             throw new Error(`Current user is not permitted to update page ${String(page.name)}`);
         const [dataToRestore, meta] = await Promise.all([
             this.svc(VersionedService).get(page.intDataId, { version: restoreVersion }),
@@ -621,7 +607,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot update a page that does not exist.');
-        if (!(await this.mayUpdate(page)))
+        if (!this.mayUpdate(page))
             throw new Error(`Current user is not permitted to update page ${String(page.name)}`);
         await this.checkLatestVersion(dataId, dataVersion);
         const pageData = await this.raw.getData(page, dataVersion);
@@ -656,7 +642,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot update a page that does not exist.');
-        if (!(await this.mayUpdate(page)))
+        if (!this.mayUpdate(page))
             throw new Error(`Current user is not permitted to update page ${String(page.name)}`);
         await this.checkLatestVersion(dataId, dataVersion);
         const pageData = await this.raw.getData(page, dataVersion);
@@ -693,7 +679,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot update a page that does not exist.');
-        if (!(await this.mayUpdate(page)))
+        if (!this.mayUpdate(page))
             throw new Error(`Current user is not permitted to update page ${String(page.name)}`);
         await this.checkLatestVersion(dataId, dataVersion);
         const pageData = await this.raw.getData(page, dataVersion);
@@ -778,7 +764,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot update a page that does not exist.');
-        if (!(await this.mayUpdate(page)))
+        if (!this.mayUpdate(page))
             throw new Error(`Current user is not permitted to update page ${String(page.name)}`);
         await this.checkLatestVersion(dataId, dataVersion);
         const pageData = await this.raw.getData(page, dataVersion);
@@ -864,7 +850,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot update a page that does not exist.');
-        if (!(await this.mayUpdate(page)))
+        if (!this.mayUpdate(page))
             throw new Error(`Current user is not permitted to update page ${String(page.name)}`);
         await this.checkLatestVersion(dataId, dataVersion);
         const pageData = await this.raw.getData(page, dataVersion);
@@ -896,7 +882,7 @@ export class PageService extends DosGatoService {
         let page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot update a page that does not exist.');
-        if (this.opRestricted(page, 'changetemplate') || !(await this.mayUpdate(page)))
+        if (this.opRestricted(page, 'changetemplate') || !this.mayUpdate(page))
             throw new Error("You are not permitted to change this page's template.");
         const pageData = await this.raw.getData(page, dataVersion);
         const extras = await this.raw.pageExtras(page);
@@ -924,7 +910,7 @@ export class PageService extends DosGatoService {
         const page = await this.raw.findById(dataId);
         if (!page)
             throw new Error('Cannot rename a page that does not exist.');
-        if (this.opRestricted(page, 'rename') || !(await this.mayMove(page)))
+        if (this.opRestricted(page, 'rename') || !this.mayMove(page))
             throw new Error('You are not permitted to rename this page.');
         const response = new PageResponse({ success: true });
         if (isNotNull(page.parentInternalId)) {
@@ -950,12 +936,11 @@ export class PageService extends DosGatoService {
     }
     async deletePages(dataIds) {
         const pages = (await Promise.all(dataIds.map(async (id) => await this.raw.findById(id)))).filter(isNotNull);
-        if (await someAsync(pages, async (page) => !(await this.mayDelete(page)))) {
+        if (pages.some(page => !this.mayDelete(page))) {
             throw new Error('Current user is not permitted to delete one or more pages');
         }
-        const currentUser = await this.currentUser();
         try {
-            await deletePages(this.svc(VersionedService), pages, currentUser.internalId);
+            await deletePages(this.svc(VersionedService), pages, this.ctx.authInfo.user.internalId);
             this.loaders.clear();
             const updated = await this.raw.findByIds(dataIds);
             return new PagesResponse({ success: true, pages: updated });
@@ -967,11 +952,10 @@ export class PageService extends DosGatoService {
     }
     async publishPageDeletions(dataIds) {
         const pages = (await Promise.all(dataIds.map(async (id) => await this.raw.findById(id)))).filter(isNotNull).filter(p => p.deleteState !== DeleteState.NOTDELETED);
-        if (await someAsync(pages, async (page) => !(await this.mayDelete(page)))) {
-            throw new Error('Current user is not permitted to delete one or more pages');
+        if (pages.some(page => !this.mayDelete(page))) {
+            throw new Error('You are not permitted to delete one or more of the selected pages.');
         }
-        const currentUser = await this.currentUser();
-        await publishPageDeletions(pages, currentUser.internalId);
+        await publishPageDeletions(pages, this.ctx.authInfo.user.internalId);
         this.loaders.clear();
         const updated = await this.raw.findByIds(pages.map(p => p.id));
         return new PagesResponse({ success: true, pages: updated });
@@ -982,8 +966,8 @@ export class PageService extends DosGatoService {
             const children = (await Promise.all(pages.map(async (page) => await this.getPageChildren(page, true)))).flat();
             pages = [...pages, ...children];
         }
-        if (await someAsync(pages, async (page) => !(await this.mayUndelete(page)))) {
-            throw new Error('Current user is not permitted to restore one or more pages');
+        if (pages.some(page => !this.mayUndelete(page))) {
+            throw new Error('You are not permitted to restore one or more of the selected pages.');
         }
         await undeletePages(pages);
         this.loaders.clear();