@webiny/api-website-builder-workflows 0.0.0-unstable.c27f4d8a31 → 0.0.0-unstable.d0f34a8194

package/features/target/WbPageDeniedFolders/WbPageDeniedFolders.js

@@ -0,0 +1,55 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { FolderLevelPermissions } from "@webiny/api-aco/features/flp/FolderLevelPermissions/index.js";
+import { ROOT_FOLDER } from "@webiny/api-aco/constants.js";
+import { WB_PAGE_FOLDER_TYPE } from "../../../constants.js";
+import { WbPageDeniedFolders } from "./abstractions.js";
+class WbPageDeniedFoldersImpl {
+    constructor(identityContext, folderLevelPermissions){
+        this.identityContext = identityContext;
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.cache = new Map();
+    }
+    async listDeniedFolderIds() {
+        if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) return [];
+        const identity = this.identityContext.getIdentity();
+        const cached = this.cache.get(identity.id);
+        if (cached) return [
+            ...cached
+        ];
+        const records = await this.folderLevelPermissions.listFolderLevelPermissions({
+            where: {
+                type: WB_PAGE_FOLDER_TYPE,
+                path_startsWith: `${ROOT_FOLDER}/`
+            }
+        });
+        const denied = [];
+        for (const record of records){
+            const canRead = await this.folderLevelPermissions.canAccessFolderContent({
+                permissions: record.permissions,
+                rwd: "r"
+            });
+            if (!canRead) denied.push(record.id);
+        }
+        this.cache.set(identity.id, denied);
+        return [
+            ...denied
+        ];
+    }
+    async createFolderReadRule() {
+        const deniedIds = await this.listDeniedFolderIds();
+        const denied = new Set(deniedIds);
+        return {
+            canReadFolder: async (folderId)=>!denied.has(folderId)
+        };
+    }
+}
+const WbPageDeniedFolders_WbPageDeniedFolders = WbPageDeniedFolders.createImplementation({
+    implementation: WbPageDeniedFoldersImpl,
+    dependencies: [
+        IdentityContext,
+        FolderLevelPermissions
+    ]
+});
+export { WbPageDeniedFolders_WbPageDeniedFolders as WbPageDeniedFolders };
+
+//# sourceMappingURL=WbPageDeniedFolders.js.map

package/features/target/WbPageDeniedFolders/WbPageDeniedFolders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageDeniedFolders/WbPageDeniedFolders.js","sources":["../../../../src/features/target/WbPageDeniedFolders/WbPageDeniedFolders.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { FolderLevelPermissions } from \"@webiny/api-aco/features/flp/FolderLevelPermissions/index.js\";\nimport { ROOT_FOLDER } from \"@webiny/api-aco/constants.js\";\nimport { WB_PAGE_FOLDER_TYPE } from \"~/constants.js\";\nimport type { FolderReadRule } from \"@webiny/api-headless-cms-workflows/features/target/FolderReadRule.js\";\nimport { WbPageDeniedFolders as Abstraction } from \"./abstractions.js\";\n\n/**\n * Registered per request, so the cache lives for one request. Keyed by identity id, because\n * `withIdentity` can switch the identity mid-request.\n */\nclass WbPageDeniedFoldersImpl implements Abstraction.Interface {\n    private readonly cache = new Map<string, string[]>();\n\n    public constructor(\n        private identityContext: IdentityContext.Interface,\n        private folderLevelPermissions: FolderLevelPermissions.Interface\n    ) {}\n\n    public async listDeniedFolderIds(): Promise<string[]> {\n        // Skipped when FLP is not in use for the identity, as the ACO CMS decorators do.\n        if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) {\n            return [];\n        }\n        const identity = this.identityContext.getIdentity();\n        const cached = this.cache.get(identity.id);\n        if (cached) {\n            return [...cached];\n        }\n\n        // Every folder path starts at the root, and the storage lists a type only by parent or by\n        // path prefix: the root prefix gives every folder of the type in one read.\n        const records = await this.folderLevelPermissions.listFolderLevelPermissions({\n            where: { type: WB_PAGE_FOLDER_TYPE, path_startsWith: `${ROOT_FOLDER}/` }\n        });\n        const denied: string[] = [];\n        for (const record of records) {\n            // In memory: the record's permissions already carry the inherited and default ones.\n            // oxlint-disable-next-line no-await-in-loop -- in memory: the record carries its permissions.\n            const canRead = await this.folderLevelPermissions.canAccessFolderContent({\n                permissions: record.permissions,\n                rwd: \"r\"\n            });\n            if (!canRead) {\n                denied.push(record.id);\n            }\n        }\n        this.cache.set(identity.id, denied);\n        return [...denied];\n    }\n\n    public async createFolderReadRule(): Promise<FolderReadRule> {\n        const deniedIds = await this.listDeniedFolderIds();\n        const denied = new Set(deniedIds);\n        return {\n            canReadFolder: async (folderId: string): Promise<boolean> => !denied.has(folderId)\n        };\n    }\n}\n\nexport const WbPageDeniedFolders = Abstraction.createImplementation({\n    implementation: WbPageDeniedFoldersImpl,\n    dependencies: [IdentityContext, FolderLevelPermissions]\n});\n"],"names":["WbPageDeniedFoldersImpl","identityContext","folderLevelPermissions","Map","identity","cached","records","WB_PAGE_FOLDER_TYPE","ROOT_FOLDER","denied","record","canRead","deniedIds","Set","folderId","WbPageDeniedFolders","Abstraction","IdentityContext","FolderLevelPermissions"],"mappings":";;;;;AAWA,MAAMA;IAGF,YACYC,eAA0C,EAC1CC,sBAAwD,CAClE;aAFUD,eAAe,GAAfA;aACAC,sBAAsB,GAAtBA;aAJK,KAAK,GAAG,IAAIC;IAK1B;IAEH,MAAa,sBAAyC;QAElD,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,4BAA4B,IACzD,OAAO,EAAE;QAEb,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAMC,SAAS,IAAI,CAAC,KAAK,CAAC,GAAG,CAACD,SAAS,EAAE;QACzC,IAAIC,QACA,OAAO;eAAIA;SAAO;QAKtB,MAAMC,UAAU,MAAM,IAAI,CAAC,sBAAsB,CAAC,0BAA0B,CAAC;YACzE,OAAO;gBAAE,MAAMC;gBAAqB,iBAAiB,GAAGC,YAAY,CAAC,CAAC;YAAC;QAC3E;QACA,MAAMC,SAAmB,EAAE;QAC3B,KAAK,MAAMC,UAAUJ,QAAS;YAG1B,MAAMK,UAAU,MAAM,IAAI,CAAC,sBAAsB,CAAC,sBAAsB,CAAC;gBACrE,aAAaD,OAAO,WAAW;gBAC/B,KAAK;YACT;YACA,IAAI,CAACC,SACDF,OAAO,IAAI,CAACC,OAAO,EAAE;QAE7B;QACA,IAAI,CAAC,KAAK,CAAC,GAAG,CAACN,SAAS,EAAE,EAAEK;QAC5B,OAAO;eAAIA;SAAO;IACtB;IAEA,MAAa,uBAAgD;QACzD,MAAMG,YAAY,MAAM,IAAI,CAAC,mBAAmB;QAChD,MAAMH,SAAS,IAAII,IAAID;QACvB,OAAO;YACH,eAAe,OAAOE,WAAuC,CAACL,OAAO,GAAG,CAACK;QAC7E;IACJ;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBhB;IAChB,cAAc;QAACiB;QAAiBC;KAAuB;AAC3D"}

package/features/target/WbPageDeniedFolders/abstractions.d.ts

@@ -0,0 +1,23 @@
+import type { FolderReadRule } from "@webiny/api-headless-cms-workflows/features/target/FolderReadRule.js";
+export interface IWbPageDeniedFolders {
+    /**
+     * Ids of the page folders whose content the current identity cannot read (Q77). Empty when
+     * folder-level permissions are not in use for the identity (e.g. API keys). Folders without
+     * permission records and the root folder are readable, so they never appear.
+     */
+    listDeniedFolderIds(): Promise<string[]>;
+    /**
+     * The same rules as a `FolderReadRule` for many page checks of the current identity
+     * (`WbPageAccess.canRead`), so the checks read no folder permissions of their own.
+     */
+    createFolderReadRule(): Promise<FolderReadRule>;
+}
+/**
+ * Folder read rules of pages for list filters, as `WbPageAccess` applies them to one page: one
+ * `listFolderLevelPermissions` of the `wb:page` folder type, evaluated in memory with
+ * `canAccessFolderContent`. Cached per identity for the request.
+ */
+export declare const WbPageDeniedFolders: import("@webiny/di").Abstraction<IWbPageDeniedFolders>;
+export declare namespace WbPageDeniedFolders {
+    type Interface = IWbPageDeniedFolders;
+}

package/features/target/WbPageDeniedFolders/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const WbPageDeniedFolders = createAbstraction("WbPageDeniedFolders");
+export { WbPageDeniedFolders };
+
+//# sourceMappingURL=abstractions.js.map

package/features/target/WbPageDeniedFolders/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageDeniedFolders/abstractions.js","sources":["../../../../src/features/target/WbPageDeniedFolders/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { FolderReadRule } from \"@webiny/api-headless-cms-workflows/features/target/FolderReadRule.js\";\n\nexport interface IWbPageDeniedFolders {\n    /**\n     * Ids of the page folders whose content the current identity cannot read (Q77). Empty when\n     * folder-level permissions are not in use for the identity (e.g. API keys). Folders without\n     * permission records and the root folder are readable, so they never appear.\n     */\n    listDeniedFolderIds(): Promise<string[]>;\n    /**\n     * The same rules as a `FolderReadRule` for many page checks of the current identity\n     * (`WbPageAccess.canRead`), so the checks read no folder permissions of their own.\n     */\n    createFolderReadRule(): Promise<FolderReadRule>;\n}\n\n/**\n * Folder read rules of pages for list filters, as `WbPageAccess` applies them to one page: one\n * `listFolderLevelPermissions` of the `wb:page` folder type, evaluated in memory with\n * `canAccessFolderContent`. Cached per identity for the request.\n */\nexport const WbPageDeniedFolders = createAbstraction<IWbPageDeniedFolders>(\"WbPageDeniedFolders\");\n\nexport namespace WbPageDeniedFolders {\n    export type Interface = IWbPageDeniedFolders;\n}\n"],"names":["WbPageDeniedFolders","createAbstraction"],"mappings":";AAsBO,MAAMA,sBAAsBC,kBAAwC"}

package/features/target/WbPageDeniedFolders/index.d.ts

@@ -0,0 +1 @@
+export { WbPageDeniedFolders } from "./abstractions.js";

package/features/target/WbPageDeniedFolders/index.js

@@ -0,0 +1 @@
+export { WbPageDeniedFolders } from "./abstractions.js";

package/features/target/WbPageFolderExistsService/WbPageFolderExistsService.d.ts

@@ -0,0 +1,15 @@
+import { GetFolderRepository } from "@webiny/api-aco/features/folder/GetFolder/abstractions.js";
+import { WbPageFolderExistsService as Abstraction } from "./abstractions.js";
+/**
+ * The ACO folder model is private (`authorization: false`): the repository read needs no
+ * `withoutAuthorization` and runs no folder-level permissions (D69).
+ */
+declare class WbPageFolderExistsServiceImpl implements Abstraction.Interface {
+    private getFolder;
+    constructor(getFolder: GetFolderRepository.Interface);
+    exists(folderId: string): Promise<boolean>;
+}
+export declare const WbPageFolderExistsService: typeof WbPageFolderExistsServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IWbPageFolderExistsService>;
+};
+export {};

package/features/target/WbPageFolderExistsService/WbPageFolderExistsService.js

@@ -0,0 +1,27 @@
+import { GetFolderRepository } from "@webiny/api-aco/features/folder/GetFolder/abstractions.js";
+import { WB_PAGE_FOLDER_TYPE } from "../../../constants.js";
+import { WbPageFolderExistsService } from "./abstractions.js";
+const FOLDER_NOT_FOUND = "Aco/Folder/NotFound";
+class WbPageFolderExistsServiceImpl {
+    constructor(getFolder){
+        this.getFolder = getFolder;
+    }
+    async exists(folderId) {
+        if (!folderId || folderId.includes("#")) return false;
+        const folder = await this.getFolder.execute(folderId);
+        if (folder.isFail()) {
+            if (folder.error.code === FOLDER_NOT_FOUND) return false;
+            throw folder.error;
+        }
+        return folder.value.type === WB_PAGE_FOLDER_TYPE;
+    }
+}
+const WbPageFolderExistsService_WbPageFolderExistsService = WbPageFolderExistsService.createImplementation({
+    implementation: WbPageFolderExistsServiceImpl,
+    dependencies: [
+        GetFolderRepository
+    ]
+});
+export { WbPageFolderExistsService_WbPageFolderExistsService as WbPageFolderExistsService };
+
+//# sourceMappingURL=WbPageFolderExistsService.js.map

package/features/target/WbPageFolderExistsService/WbPageFolderExistsService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageFolderExistsService/WbPageFolderExistsService.js","sources":["../../../../src/features/target/WbPageFolderExistsService/WbPageFolderExistsService.ts"],"sourcesContent":["import { GetFolderRepository } from \"@webiny/api-aco/features/folder/GetFolder/abstractions.js\";\nimport { WB_PAGE_FOLDER_TYPE } from \"~/constants.js\";\nimport { WbPageFolderExistsService as Abstraction } from \"./abstractions.js\";\n\n/** Compared by code, as the CMS service does: no dependency on one ACO module instance. */\nconst FOLDER_NOT_FOUND = \"Aco/Folder/NotFound\";\n\n/**\n * The ACO folder model is private (`authorization: false`): the repository read needs no\n * `withoutAuthorization` and runs no folder-level permissions (D69).\n */\nclass WbPageFolderExistsServiceImpl implements Abstraction.Interface {\n    public constructor(private getFolder: GetFolderRepository.Interface) {}\n\n    public async exists(folderId: string): Promise<boolean> {\n        // Folder ids are plain entry ids; the repository would read `<id>#<n>` as a revision.\n        if (!folderId || folderId.includes(\"#\")) {\n            return false;\n        }\n        const folder = await this.getFolder.execute(folderId);\n        if (folder.isFail()) {\n            if (folder.error.code === FOLDER_NOT_FOUND) {\n                return false;\n            }\n            throw folder.error;\n        }\n        return folder.value.type === WB_PAGE_FOLDER_TYPE;\n    }\n}\n\nexport const WbPageFolderExistsService = Abstraction.createImplementation({\n    implementation: WbPageFolderExistsServiceImpl,\n    dependencies: [GetFolderRepository]\n});\n"],"names":["FOLDER_NOT_FOUND","WbPageFolderExistsServiceImpl","getFolder","folderId","folder","WB_PAGE_FOLDER_TYPE","WbPageFolderExistsService","Abstraction","GetFolderRepository"],"mappings":";;;AAKA,MAAMA,mBAAmB;AAMzB,MAAMC;IACF,YAA2BC,SAAwC,CAAE;aAA1CA,SAAS,GAATA;IAA2C;IAEtE,MAAa,OAAOC,QAAgB,EAAoB;QAEpD,IAAI,CAACA,YAAYA,SAAS,QAAQ,CAAC,MAC/B,OAAO;QAEX,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;QAC5C,IAAIC,OAAO,MAAM,IAAI;YACjB,IAAIA,OAAO,KAAK,CAAC,IAAI,KAAKJ,kBACtB,OAAO;YAEX,MAAMI,OAAO,KAAK;QACtB;QACA,OAAOA,OAAO,KAAK,CAAC,IAAI,KAAKC;IACjC;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAAgC,CAAC;IACtE,gBAAgBN;IAChB,cAAc;QAACO;KAAoB;AACvC"}

package/features/target/WbPageFolderExistsService/abstractions.d.ts

@@ -0,0 +1,16 @@
+export interface IWbPageFolderExistsService {
+    /**
+     * Whether a `wb:page` folder with this id exists. A missing folder, another folder type or an
+     * id that is no folder id (empty, or with `#`) answer `false`; a failed read throws.
+     */
+    exists(folderId: string): Promise<boolean>;
+}
+/**
+ * The dangling-folder check of the workflow editor (D69, R125): reads the folder with ACO's
+ * repository, without folder-level permissions, and answers only a boolean, never folder data.
+ * The caller checks `editor` first (`WebsiteBuilderPageFolderExistsUseCase`).
+ */
+export declare const WbPageFolderExistsService: import("@webiny/di").Abstraction<IWbPageFolderExistsService>;
+export declare namespace WbPageFolderExistsService {
+    type Interface = IWbPageFolderExistsService;
+}

package/features/target/WbPageFolderExistsService/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const WbPageFolderExistsService = createAbstraction("WbPageFolderExistsService");
+export { WbPageFolderExistsService };
+
+//# sourceMappingURL=abstractions.js.map

package/features/target/WbPageFolderExistsService/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageFolderExistsService/abstractions.js","sources":["../../../../src/features/target/WbPageFolderExistsService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IWbPageFolderExistsService {\n    /**\n     * Whether a `wb:page` folder with this id exists. A missing folder, another folder type or an\n     * id that is no folder id (empty, or with `#`) answer `false`; a failed read throws.\n     */\n    exists(folderId: string): Promise<boolean>;\n}\n\n/**\n * The dangling-folder check of the workflow editor (D69, R125): reads the folder with ACO's\n * repository, without folder-level permissions, and answers only a boolean, never folder data.\n * The caller checks `editor` first (`WebsiteBuilderPageFolderExistsUseCase`).\n */\nexport const WbPageFolderExistsService = createAbstraction<IWbPageFolderExistsService>(\n    \"WbPageFolderExistsService\"\n);\n\nexport namespace WbPageFolderExistsService {\n    export type Interface = IWbPageFolderExistsService;\n}\n"],"names":["WbPageFolderExistsService","createAbstraction"],"mappings":";AAeO,MAAMA,4BAA4BC,kBACrC"}

package/features/target/WbPageFolderExistsService/index.d.ts

@@ -0,0 +1 @@
+export { WbPageFolderExistsService } from "./abstractions.js";

package/features/target/WbPageFolderExistsService/index.js

@@ -0,0 +1 @@
+export { WbPageFolderExistsService } from "./abstractions.js";

package/features/target/WbPageReviewNamespace.d.ts

@@ -0,0 +1,14 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { CmsEntryReviewNamespace } from "@webiny/api-headless-cms-workflows/features/target/CmsEntryReviewNamespace/index.js";
+/**
+ * Pages are entries of the private CMS model `wbyWbPage` (`wbPage` with legacy models); their
+ * review namespace is `wb.page` (R51), never a `cms.*` one. The page model publishes no CMS entry
+ * events, so the page rules listen to the Website Builder page events (`WbHooksFeature`).
+ */
+declare class WbPageReviewNamespaceImpl implements CmsEntryReviewNamespace.Interface {
+    resolve(model: CmsModel): string | null;
+}
+export declare const WbPageReviewNamespace: typeof WbPageReviewNamespaceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms-workflows/features/target/CmsEntryReviewNamespace/abstractions").ICmsEntryReviewNamespace>;
+};
+export {};

package/features/target/WbPageReviewNamespace.js

@@ -0,0 +1,15 @@
+import { PAGE_MODEL_ID } from "@webiny/api-website-builder/domain/page/page.model.js";
+import { CmsEntryReviewNamespace } from "@webiny/api-headless-cms-workflows/features/target/CmsEntryReviewNamespace/index.js";
+import { WB_PAGE_NAMESPACE } from "../../constants.js";
+class WbPageReviewNamespaceImpl {
+    resolve(model) {
+        return model.modelId === PAGE_MODEL_ID ? WB_PAGE_NAMESPACE : null;
+    }
+}
+const WbPageReviewNamespace = CmsEntryReviewNamespace.createImplementation({
+    implementation: WbPageReviewNamespaceImpl,
+    dependencies: []
+});
+export { WbPageReviewNamespace };
+
+//# sourceMappingURL=WbPageReviewNamespace.js.map

package/features/target/WbPageReviewNamespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewNamespace.js","sources":["../../../src/features/target/WbPageReviewNamespace.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { PAGE_MODEL_ID } from \"@webiny/api-website-builder/domain/page/page.model.js\";\nimport { CmsEntryReviewNamespace } from \"@webiny/api-headless-cms-workflows/features/target/CmsEntryReviewNamespace/index.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\n\n/**\n * Pages are entries of the private CMS model `wbyWbPage` (`wbPage` with legacy models); their\n * review namespace is `wb.page` (R51), never a `cms.*` one. The page model publishes no CMS entry\n * events, so the page rules listen to the Website Builder page events (`WbHooksFeature`).\n */\nclass WbPageReviewNamespaceImpl implements CmsEntryReviewNamespace.Interface {\n    public resolve(model: CmsModel): string | null {\n        return model.modelId === PAGE_MODEL_ID ? WB_PAGE_NAMESPACE : null;\n    }\n}\n\nexport const WbPageReviewNamespace = CmsEntryReviewNamespace.createImplementation({\n    implementation: WbPageReviewNamespaceImpl,\n    dependencies: []\n});\n"],"names":["WbPageReviewNamespaceImpl","model","PAGE_MODEL_ID","WB_PAGE_NAMESPACE","WbPageReviewNamespace","CmsEntryReviewNamespace"],"mappings":";;;AAUA,MAAMA;IACK,QAAQC,KAAe,EAAiB;QAC3C,OAAOA,MAAM,OAAO,KAAKC,gBAAgBC,oBAAoB;IACjE;AACJ;AAEO,MAAMC,wBAAwBC,wBAAwB,oBAAoB,CAAC;IAC9E,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/features/target/WbPageReviewReadFilter/WbPageReviewReadFilter.d.ts

@@ -0,0 +1,17 @@
+import { WbPermissions } from "@webiny/api-website-builder/features/permissions/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListReviewedModelsUseCase } from "@webiny/api-workflows/features/review/ListReviewedModels/index.js";
+import { WbPageDeniedFolders } from "../WbPageDeniedFolders/index.js";
+import { WbPageReviewReadFilter as Abstraction } from "./abstractions.js";
+declare class WbPageReviewReadFilterImpl implements Abstraction.Interface {
+    private permissions;
+    private identityContext;
+    private deniedFolders;
+    private listReviewedModels;
+    constructor(permissions: WbPermissions.Interface, identityContext: IdentityContext.Interface, deniedFolders: WbPageDeniedFolders.Interface, listReviewedModels: ListReviewedModelsUseCase.Interface);
+    build(): Abstraction.Return;
+}
+export declare const WbPageReviewReadFilter: typeof WbPageReviewReadFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IWbPageReviewReadFilter>;
+};
+export {};

package/features/target/WbPageReviewReadFilter/WbPageReviewReadFilter.js

@@ -0,0 +1,53 @@
+import { Result } from "@webiny/feature/api";
+import { WbPermissions } from "@webiny/api-website-builder/features/permissions/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ReviewPersistenceError } from "@webiny/api-workflows/domain/review/errors.js";
+import { ListReviewedModelsUseCase } from "@webiny/api-workflows/features/review/ListReviewedModels/index.js";
+import { WB_PAGE_NAMESPACE } from "../../../constants.js";
+import { WbPageDeniedFolders } from "../WbPageDeniedFolders/index.js";
+import { WbPageReviewReadFilter } from "./abstractions.js";
+class WbPageReviewReadFilterImpl {
+    constructor(permissions, identityContext, deniedFolders, listReviewedModels){
+        this.permissions = permissions;
+        this.identityContext = identityContext;
+        this.deniedFolders = deniedFolders;
+        this.listReviewedModels = listReviewedModels;
+    }
+    async build() {
+        const identity = this.identityContext.getIdentity();
+        const filter = {
+            models: [],
+            ownOnlyModels: [],
+            authorId: identity.id,
+            deniedFolderIds: []
+        };
+        try {
+            if (!await this.permissions.canRead("page")) return Result.ok(filter);
+            if (await this.permissions.onlyOwnRecords("page")) filter.ownOnlyModels.push(WB_PAGE_NAMESPACE);
+            else filter.models.push(WB_PAGE_NAMESPACE);
+        } catch (error) {
+            return Result.fail(new ReviewPersistenceError(error instanceof Error ? error : new Error(String(error))));
+        }
+        const reviewedModels = await this.listReviewedModels.execute();
+        if (reviewedModels.isFail()) return Result.fail(reviewedModels.error);
+        if (!reviewedModels.value.includes(WB_PAGE_NAMESPACE)) return Result.ok(filter);
+        try {
+            filter.deniedFolderIds = await this.deniedFolders.listDeniedFolderIds();
+        } catch (error) {
+            return Result.fail(new ReviewPersistenceError(error instanceof Error ? error : new Error(String(error))));
+        }
+        return Result.ok(filter);
+    }
+}
+const WbPageReviewReadFilter_WbPageReviewReadFilter = WbPageReviewReadFilter.createImplementation({
+    implementation: WbPageReviewReadFilterImpl,
+    dependencies: [
+        WbPermissions,
+        IdentityContext,
+        WbPageDeniedFolders,
+        ListReviewedModelsUseCase
+    ]
+});
+export { WbPageReviewReadFilter_WbPageReviewReadFilter as WbPageReviewReadFilter };
+
+//# sourceMappingURL=WbPageReviewReadFilter.js.map

package/features/target/WbPageReviewReadFilter/WbPageReviewReadFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewReadFilter/WbPageReviewReadFilter.js","sources":["../../../../src/features/target/WbPageReviewReadFilter/WbPageReviewReadFilter.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { WbPermissions } from \"@webiny/api-website-builder/features/permissions/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { ReviewListReadFilter } from \"@webiny/api-workflows/domain/review/types.js\";\nimport { ReviewPersistenceError } from \"@webiny/api-workflows/domain/review/errors.js\";\nimport { ListReviewedModelsUseCase } from \"@webiny/api-workflows/features/review/ListReviewedModels/index.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\nimport { WbPageDeniedFolders } from \"../WbPageDeniedFolders/index.js\";\nimport { WbPageReviewReadFilter as Abstraction } from \"./abstractions.js\";\n\nclass WbPageReviewReadFilterImpl implements Abstraction.Interface {\n    public constructor(\n        private permissions: WbPermissions.Interface,\n        private identityContext: IdentityContext.Interface,\n        private deniedFolders: WbPageDeniedFolders.Interface,\n        private listReviewedModels: ListReviewedModelsUseCase.Interface\n    ) {}\n\n    public async build(): Abstraction.Return {\n        const identity = this.identityContext.getIdentity();\n        const filter: ReviewListReadFilter = {\n            models: [],\n            ownOnlyModels: [],\n            authorId: identity.id,\n            deniedFolderIds: []\n        };\n        try {\n            if (!(await this.permissions.canRead(\"page\"))) {\n                return Result.ok(filter);\n            }\n            if (await this.permissions.onlyOwnRecords(\"page\")) {\n                filter.ownOnlyModels.push(WB_PAGE_NAMESPACE);\n            } else {\n                filter.models.push(WB_PAGE_NAMESPACE);\n            }\n        } catch (error) {\n            return Result.fail(\n                new ReviewPersistenceError(\n                    error instanceof Error ? error : new Error(String(error))\n                )\n            );\n        }\n\n        // Folder rules only when pages have active reviews: otherwise no row can match.\n        const reviewedModels = await this.listReviewedModels.execute();\n        if (reviewedModels.isFail()) {\n            return Result.fail(reviewedModels.error);\n        }\n        if (!reviewedModels.value.includes(WB_PAGE_NAMESPACE)) {\n            return Result.ok(filter);\n        }\n        try {\n            filter.deniedFolderIds = await this.deniedFolders.listDeniedFolderIds();\n        } catch (error) {\n            return Result.fail(\n                new ReviewPersistenceError(\n                    error instanceof Error ? error : new Error(String(error))\n                )\n            );\n        }\n        return Result.ok(filter);\n    }\n}\n\nexport const WbPageReviewReadFilter = Abstraction.createImplementation({\n    implementation: WbPageReviewReadFilterImpl,\n    dependencies: [WbPermissions, IdentityContext, WbPageDeniedFolders, ListReviewedModelsUseCase]\n});\n"],"names":["WbPageReviewReadFilterImpl","permissions","identityContext","deniedFolders","listReviewedModels","identity","filter","Result","WB_PAGE_NAMESPACE","error","ReviewPersistenceError","Error","String","reviewedModels","WbPageReviewReadFilter","Abstraction","WbPermissions","IdentityContext","WbPageDeniedFolders","ListReviewedModelsUseCase"],"mappings":";;;;;;;;AAUA,MAAMA;IACF,YACYC,WAAoC,EACpCC,eAA0C,EAC1CC,aAA4C,EAC5CC,kBAAuD,CACjE;aAJUH,WAAW,GAAXA;aACAC,eAAe,GAAfA;aACAC,aAAa,GAAbA;aACAC,kBAAkB,GAAlBA;IACT;IAEH,MAAa,QAA4B;QACrC,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAMC,SAA+B;YACjC,QAAQ,EAAE;YACV,eAAe,EAAE;YACjB,UAAUD,SAAS,EAAE;YACrB,iBAAiB,EAAE;QACvB;QACA,IAAI;YACA,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,SACjC,OAAOE,OAAO,EAAE,CAACD;YAErB,IAAI,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,SACtCA,OAAO,aAAa,CAAC,IAAI,CAACE;iBAE1BF,OAAO,MAAM,CAAC,IAAI,CAACE;QAE3B,EAAE,OAAOC,OAAO;YACZ,OAAOF,OAAO,IAAI,CACd,IAAIG,uBACAD,iBAAiBE,QAAQF,QAAQ,IAAIE,MAAMC,OAAOH;QAG9D;QAGA,MAAMI,iBAAiB,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO;QAC5D,IAAIA,eAAe,MAAM,IACrB,OAAON,OAAO,IAAI,CAACM,eAAe,KAAK;QAE3C,IAAI,CAACA,eAAe,KAAK,CAAC,QAAQ,CAACL,oBAC/B,OAAOD,OAAO,EAAE,CAACD;QAErB,IAAI;YACAA,OAAO,eAAe,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,mBAAmB;QACzE,EAAE,OAAOG,OAAO;YACZ,OAAOF,OAAO,IAAI,CACd,IAAIG,uBACAD,iBAAiBE,QAAQF,QAAQ,IAAIE,MAAMC,OAAOH;QAG9D;QACA,OAAOF,OAAO,EAAE,CAACD;IACrB;AACJ;AAEO,MAAMQ,gDAAyBC,uBAAAA,oBAAgC,CAAC;IACnE,gBAAgBf;IAChB,cAAc;QAACgB;QAAeC;QAAiBC;QAAqBC;KAA0B;AAClG"}

package/features/target/WbPageReviewReadFilter/abstractions.d.ts

@@ -0,0 +1,21 @@
+import { type Result } from "@webiny/feature/api";
+import type { ReviewListReadFilter } from "@webiny/api-workflows/domain/review/types.js";
+import type { ReviewPersistenceError } from "@webiny/api-workflows/domain/review/errors.js";
+export interface IWbPageReviewReadFilter {
+    /**
+     * The page review list read filter (Q77) of the current identity. A failed permission or
+     * folder permission read is a persistence error (R87).
+     */
+    build(): Promise<Result<ReviewListReadFilter, ReviewPersistenceError>>;
+}
+/**
+ * What the Website Builder page list would show the current identity, as a review list filter:
+ * pages are readable with `canRead("page")`, own-only when `onlyOwnRecords("page")` (as
+ * `ListPagesUseCase` filters by `createdBy`); folders come from `WbPageDeniedFolders`, read only
+ * when pages have active reviews (`ListReviewedModelsUseCase`).
+ */
+export declare const WbPageReviewReadFilter: import("@webiny/di").Abstraction<IWbPageReviewReadFilter>;
+export declare namespace WbPageReviewReadFilter {
+    type Interface = IWbPageReviewReadFilter;
+    type Return = Promise<Result<ReviewListReadFilter, ReviewPersistenceError>>;
+}

package/features/target/WbPageReviewReadFilter/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const WbPageReviewReadFilter = createAbstraction("WbPageReviewReadFilter");
+export { WbPageReviewReadFilter };
+
+//# sourceMappingURL=abstractions.js.map

package/features/target/WbPageReviewReadFilter/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewReadFilter/abstractions.js","sources":["../../../../src/features/target/WbPageReviewReadFilter/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ReviewListReadFilter } from \"@webiny/api-workflows/domain/review/types.js\";\nimport type { ReviewPersistenceError } from \"@webiny/api-workflows/domain/review/errors.js\";\n\nexport interface IWbPageReviewReadFilter {\n    /**\n     * The page review list read filter (Q77) of the current identity. A failed permission or\n     * folder permission read is a persistence error (R87).\n     */\n    build(): Promise<Result<ReviewListReadFilter, ReviewPersistenceError>>;\n}\n\n/**\n * What the Website Builder page list would show the current identity, as a review list filter:\n * pages are readable with `canRead(\"page\")`, own-only when `onlyOwnRecords(\"page\")` (as\n * `ListPagesUseCase` filters by `createdBy`); folders come from `WbPageDeniedFolders`, read only\n * when pages have active reviews (`ListReviewedModelsUseCase`).\n */\nexport const WbPageReviewReadFilter =\n    createAbstraction<IWbPageReviewReadFilter>(\"WbPageReviewReadFilter\");\n\nexport namespace WbPageReviewReadFilter {\n    export type Interface = IWbPageReviewReadFilter;\n    export type Return = Promise<Result<ReviewListReadFilter, ReviewPersistenceError>>;\n}\n"],"names":["WbPageReviewReadFilter","createAbstraction"],"mappings":";AAkBO,MAAMA,yBACTC,kBAA2C"}

package/features/target/WbPageReviewReadFilter/index.d.ts

@@ -0,0 +1 @@
+export { WbPageReviewReadFilter } from "./abstractions.js";

package/features/target/WbPageReviewReadFilter/index.js

@@ -0,0 +1 @@
+export { WbPageReviewReadFilter } from "./abstractions.js";

package/features/target/WbPageReviewTargetEditor.d.ts

@@ -0,0 +1,33 @@
+import { Result } from "@webiny/feature/api";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { UpdatePageUseCase } from "@webiny/api-website-builder/features/pages/UpdatePage/index.js";
+import { ReviewTargetEditor } from "@webiny/api-workflows/features/review/ReviewTargetEditor/index.js";
+import type { ReviewTargetContent, ReviewTargetEditorReadParams, ReviewTargetEditorUpdateParams, ReviewTargetEditorUpdateResult } from "@webiny/api-workflows/features/review/ReviewTargetEditor/abstractions.js";
+import { ReviewTargetEditorError } from "@webiny/api-workflows/domain/review/errors.js";
+import { WbPageTargetReader } from "./WbPageTargetReader/index.js";
+import { WbPageAccess } from "./WbPageAccess/index.js";
+/**
+ * The `wb.page` editor of the AI step's built-in tools (spec 9.3, R172). `read` returns the whole
+ * page (the element tree as a summary); `update` writes `properties.title` and the SEO scalars
+ * `properties.seo.{title,description,canonicalUrl,noIndex,noFollow}` only, atomically, as the full
+ * merged `properties` through the page update (`properties` only, so the element tree, bindings,
+ * metadata and location are never in the write). The page is read as the request identity and
+ * `WbPageAccess.canRead` decides whether it is visible; the write goes through
+ * `UpdatePageUseCase`, which checks the write permission itself. The save-block bypass is the
+ * tool's business (R173): this class neither reads nor sets it. Throws and failed Results become
+ * failed Results with a fixed text, the real error is logged (R87).
+ */
+declare class WbPageReviewTargetEditorImpl implements ReviewTargetEditor.Interface {
+    private targets;
+    private access;
+    private updatePage;
+    private logger;
+    constructor(targets: WbPageTargetReader.Interface, access: WbPageAccess.Interface, updatePage: UpdatePageUseCase.Interface, logger: Logger.Interface);
+    canEdit(model: string): boolean;
+    read(params: ReviewTargetEditorReadParams): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;
+    update(params: ReviewTargetEditorUpdateParams): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;
+}
+export declare const WbPageReviewTargetEditor: typeof WbPageReviewTargetEditorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/review/ReviewTargetEditor/abstractions.js").IReviewTargetEditor>;
+};
+export {};

package/features/target/WbPageReviewTargetEditor.js

@@ -0,0 +1,109 @@
+import { Result } from "@webiny/feature/api";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { UpdatePageUseCase } from "@webiny/api-website-builder/features/pages/UpdatePage/index.js";
+import { ReviewTargetEditor } from "@webiny/api-workflows/features/review/ReviewTargetEditor/index.js";
+import { ReviewTargetEditorError } from "@webiny/api-workflows/domain/review/errors.js";
+import { WB_PAGE_NAMESPACE } from "../../constants.js";
+import { WbPageTargetReader } from "./WbPageTargetReader/index.js";
+import { WbPageAccess } from "./WbPageAccess/index.js";
+import { toWbPageEditorFields } from "./toWbPageEditorFields.js";
+import { describeWbPageEditorValue, isWbPageEditorValue } from "./isWbPageEditorValue.js";
+import { toWbPageProperties } from "./toWbPageProperties.js";
+import { hasErrorSource } from "@webiny/api-workflows/domain/hasErrorSource.js";
+class WbPageReviewTargetEditorImpl {
+    constructor(targets, access, updatePage, logger){
+        this.targets = targets;
+        this.access = access;
+        this.updatePage = updatePage;
+        this.logger = logger;
+    }
+    canEdit(model) {
+        return model === WB_PAGE_NAMESPACE;
+    }
+    async read(params) {
+        try {
+            const target = await this.targets.read({
+                model: params.model,
+                targetRevisionId: params.targetRevisionId
+            });
+            if (!target || target.page.entryId !== params.targetId || !await this.access.canRead(target)) return Result.fail(new ReviewTargetEditorError("The target was not found."));
+            return Result.ok({
+                title: target.page.properties.title,
+                fields: toWbPageEditorFields(target.page)
+            });
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                model: params.model,
+                targetId: params.targetId
+            }, "Could not read the target for the AI editor.");
+            return Result.fail(new ReviewTargetEditorError("The target could not be read."));
+        }
+    }
+    async update(params) {
+        const paths = Object.keys(params.values);
+        if (0 === paths.length) return Result.fail(new ReviewTargetEditorError("No fields were given."));
+        let properties;
+        try {
+            const target = await this.targets.read({
+                model: params.model,
+                targetRevisionId: params.targetRevisionId
+            });
+            if (!target || target.page.entryId !== params.targetId || !await this.access.canRead(target)) return Result.fail(new ReviewTargetEditorError("The target was not found."));
+            const fields = new Map();
+            for (const field of toWbPageEditorFields(target.page))fields.set(field.path, field);
+            const problems = [];
+            for (const path of paths){
+                const field = fields.get(path);
+                if (field) if (field.writable) {
+                    if (!isWbPageEditorValue(path, params.values[path])) problems.push(`The field "${path}" expects ${describeWbPageEditorValue(path)}.`);
+                } else problems.push(`The field "${path}" is read-only.`);
+                else problems.push(`Unknown field "${path}". Use the paths returned by readTarget.`);
+            }
+            if (problems.length > 0) return Result.fail(new ReviewTargetEditorError(problems.join(" ")));
+            properties = toWbPageProperties(target.page.properties, params.values);
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                model: params.model,
+                targetId: params.targetId
+            }, "Could not read the target for the AI editor.");
+            return Result.fail(new ReviewTargetEditorError("The target could not be read."));
+        }
+        try {
+            const result = await this.updatePage.execute(params.targetRevisionId, {
+                properties
+            });
+            if (result.isFail()) {
+                this.logger.error({
+                    err: hasErrorSource(result.error) ? result.error.source : result.error,
+                    model: params.model,
+                    targetId: params.targetId
+                }, "Could not update the target from the AI editor.");
+                return Result.fail(new ReviewTargetEditorError("The target could not be updated."));
+            }
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                model: params.model,
+                targetId: params.targetId
+            }, "Could not update the target from the AI editor.");
+            return Result.fail(new ReviewTargetEditorError("The target could not be updated."));
+        }
+        return Result.ok({
+            applied: paths
+        });
+    }
+}
+const WbPageReviewTargetEditor = ReviewTargetEditor.createImplementation({
+    implementation: WbPageReviewTargetEditorImpl,
+    dependencies: [
+        WbPageTargetReader,
+        WbPageAccess,
+        UpdatePageUseCase,
+        Logger
+    ]
+});
+export { WbPageReviewTargetEditor };
+
+//# sourceMappingURL=WbPageReviewTargetEditor.js.map

package/features/target/WbPageReviewTargetEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewTargetEditor.js","sources":["../../../src/features/target/WbPageReviewTargetEditor.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { UpdatePageUseCase } from \"@webiny/api-website-builder/features/pages/UpdatePage/index.js\";\nimport { ReviewTargetEditor } from \"@webiny/api-workflows/features/review/ReviewTargetEditor/index.js\";\nimport type {\n    ReviewTargetContent,\n    ReviewTargetEditorField,\n    ReviewTargetEditorReadParams,\n    ReviewTargetEditorUpdateParams,\n    ReviewTargetEditorUpdateResult\n} from \"@webiny/api-workflows/features/review/ReviewTargetEditor/abstractions.js\";\nimport { ReviewTargetEditorError } from \"@webiny/api-workflows/domain/review/errors.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\nimport { WbPageTargetReader } from \"./WbPageTargetReader/index.js\";\nimport { WbPageAccess } from \"./WbPageAccess/index.js\";\nimport { toWbPageEditorFields } from \"./toWbPageEditorFields.js\";\nimport { describeWbPageEditorValue, isWbPageEditorValue } from \"./isWbPageEditorValue.js\";\nimport { toWbPageProperties } from \"./toWbPageProperties.js\";\nimport { hasErrorSource } from \"@webiny/api-workflows/domain/hasErrorSource.js\";\n\n/**\n * The `wb.page` editor of the AI step's built-in tools (spec 9.3, R172). `read` returns the whole\n * page (the element tree as a summary); `update` writes `properties.title` and the SEO scalars\n * `properties.seo.{title,description,canonicalUrl,noIndex,noFollow}` only, atomically, as the full\n * merged `properties` through the page update (`properties` only, so the element tree, bindings,\n * metadata and location are never in the write). The page is read as the request identity and\n * `WbPageAccess.canRead` decides whether it is visible; the write goes through\n * `UpdatePageUseCase`, which checks the write permission itself. The save-block bypass is the\n * tool's business (R173): this class neither reads nor sets it. Throws and failed Results become\n * failed Results with a fixed text, the real error is logged (R87).\n */\nclass WbPageReviewTargetEditorImpl implements ReviewTargetEditor.Interface {\n    public constructor(\n        private targets: WbPageTargetReader.Interface,\n        private access: WbPageAccess.Interface,\n        private updatePage: UpdatePageUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public canEdit(model: string): boolean {\n        return model === WB_PAGE_NAMESPACE;\n    }\n\n    public async read(\n        params: ReviewTargetEditorReadParams\n    ): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>> {\n        try {\n            const target = await this.targets.read({\n                model: params.model,\n                targetRevisionId: params.targetRevisionId\n            });\n            if (\n                !target ||\n                target.page.entryId !== params.targetId ||\n                !(await this.access.canRead(target))\n            ) {\n                return Result.fail(new ReviewTargetEditorError(\"The target was not found.\"));\n            }\n\n            // Inside the try: a malformed page makes these throw, and that must be a failed\n            // Result, never a rejection (R87).\n            return Result.ok({\n                title: target.page.properties.title,\n                fields: toWbPageEditorFields(target.page)\n            });\n        } catch (error) {\n            this.logger.error(\n                { err: error, model: params.model, targetId: params.targetId },\n                \"Could not read the target for the AI editor.\"\n            );\n            return Result.fail(new ReviewTargetEditorError(\"The target could not be read.\"));\n        }\n    }\n\n    public async update(\n        params: ReviewTargetEditorUpdateParams\n    ): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>> {\n        const paths = Object.keys(params.values);\n        if (paths.length === 0) {\n            return Result.fail(new ReviewTargetEditorError(\"No fields were given.\"));\n        }\n\n        let properties: Record<string, unknown>;\n        try {\n            const target = await this.targets.read({\n                model: params.model,\n                targetRevisionId: params.targetRevisionId\n            });\n            if (\n                !target ||\n                target.page.entryId !== params.targetId ||\n                !(await this.access.canRead(target))\n            ) {\n                return Result.fail(new ReviewTargetEditorError(\"The target was not found.\"));\n            }\n\n            // A Map, so a key such as \"__proto__\" is just an unknown path.\n            const fields = new Map<string, ReviewTargetEditorField>();\n            for (const field of toWbPageEditorFields(target.page)) {\n                fields.set(field.path, field);\n            }\n            const problems: string[] = [];\n            for (const path of paths) {\n                const field = fields.get(path);\n                if (!field) {\n                    problems.push(`Unknown field \"${path}\". Use the paths returned by readTarget.`);\n                } else if (!field.writable) {\n                    problems.push(`The field \"${path}\" is read-only.`);\n                } else if (!isWbPageEditorValue(path, params.values[path])) {\n                    problems.push(\n                        `The field \"${path}\" expects ${describeWbPageEditorValue(path)}.`\n                    );\n                }\n            }\n            if (problems.length > 0) {\n                return Result.fail(new ReviewTargetEditorError(problems.join(\" \")));\n            }\n\n            properties = toWbPageProperties(target.page.properties, params.values);\n        } catch (error) {\n            this.logger.error(\n                { err: error, model: params.model, targetId: params.targetId },\n                \"Could not read the target for the AI editor.\"\n            );\n            return Result.fail(new ReviewTargetEditorError(\"The target could not be read.\"));\n        }\n\n        try {\n            const result = await this.updatePage.execute(params.targetRevisionId, { properties });\n            if (result.isFail()) {\n                // The page use case wraps CMS messages, so its text is never shown to the model.\n                this.logger.error(\n                    {\n                        err: hasErrorSource(result.error) ? result.error.source : result.error,\n                        model: params.model,\n                        targetId: params.targetId\n                    },\n                    \"Could not update the target from the AI editor.\"\n                );\n                return Result.fail(new ReviewTargetEditorError(\"The target could not be updated.\"));\n            }\n        } catch (error) {\n            this.logger.error(\n                { err: error, model: params.model, targetId: params.targetId },\n                \"Could not update the target from the AI editor.\"\n            );\n            return Result.fail(new ReviewTargetEditorError(\"The target could not be updated.\"));\n        }\n\n        return Result.ok({ applied: paths });\n    }\n}\n\nexport const WbPageReviewTargetEditor = ReviewTargetEditor.createImplementation({\n    implementation: WbPageReviewTargetEditorImpl,\n    dependencies: [WbPageTargetReader, WbPageAccess, UpdatePageUseCase, Logger]\n});\n"],"names":["WbPageReviewTargetEditorImpl","targets","access","updatePage","logger","model","WB_PAGE_NAMESPACE","params","target","Result","ReviewTargetEditorError","toWbPageEditorFields","error","paths","Object","properties","fields","Map","field","problems","path","isWbPageEditorValue","describeWbPageEditorValue","toWbPageProperties","result","hasErrorSource","WbPageReviewTargetEditor","ReviewTargetEditor","WbPageTargetReader","WbPageAccess","UpdatePageUseCase","Logger"],"mappings":";;;;;;;;;;;;AA+BA,MAAMA;IACF,YACYC,OAAqC,EACrCC,MAA8B,EAC9BC,UAAuC,EACvCC,MAAwB,CAClC;aAJUH,OAAO,GAAPA;aACAC,MAAM,GAANA;aACAC,UAAU,GAAVA;aACAC,MAAM,GAANA;IACT;IAEI,QAAQC,KAAa,EAAW;QACnC,OAAOA,UAAUC;IACrB;IAEA,MAAa,KACTC,MAAoC,EACyB;QAC7D,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;gBACnC,OAAOD,OAAO,KAAK;gBACnB,kBAAkBA,OAAO,gBAAgB;YAC7C;YACA,IACI,CAACC,UACDA,OAAO,IAAI,CAAC,OAAO,KAAKD,OAAO,QAAQ,IACvC,CAAE,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAACC,SAE5B,OAAOC,OAAO,IAAI,CAAC,IAAIC,wBAAwB;YAKnD,OAAOD,OAAO,EAAE,CAAC;gBACb,OAAOD,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK;gBACnC,QAAQG,qBAAqBH,OAAO,IAAI;YAC5C;QACJ,EAAE,OAAOI,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,OAAOL,OAAO,KAAK;gBAAE,UAAUA,OAAO,QAAQ;YAAC,GAC7D;YAEJ,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QACnD;IACJ;IAEA,MAAa,OACTH,MAAsC,EACkC;QACxE,MAAMM,QAAQC,OAAO,IAAI,CAACP,OAAO,MAAM;QACvC,IAAIM,AAAiB,MAAjBA,MAAM,MAAM,EACZ,OAAOJ,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QAGnD,IAAIK;QACJ,IAAI;YACA,MAAMP,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;gBACnC,OAAOD,OAAO,KAAK;gBACnB,kBAAkBA,OAAO,gBAAgB;YAC7C;YACA,IACI,CAACC,UACDA,OAAO,IAAI,CAAC,OAAO,KAAKD,OAAO,QAAQ,IACvC,CAAE,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAACC,SAE5B,OAAOC,OAAO,IAAI,CAAC,IAAIC,wBAAwB;YAInD,MAAMM,SAAS,IAAIC;YACnB,KAAK,MAAMC,SAASP,qBAAqBH,OAAO,IAAI,EAChDQ,OAAO,GAAG,CAACE,MAAM,IAAI,EAAEA;YAE3B,MAAMC,WAAqB,EAAE;YAC7B,KAAK,MAAMC,QAAQP,MAAO;gBACtB,MAAMK,QAAQF,OAAO,GAAG,CAACI;gBACzB,IAAKF,OAEE,IAAKA,MAAM,QAAQ,EAEnB;oBAAA,IAAI,CAACG,oBAAoBD,MAAMb,OAAO,MAAM,CAACa,KAAK,GACrDD,SAAS,IAAI,CACT,CAAC,WAAW,EAAEC,KAAK,UAAU,EAAEE,0BAA0BF,MAAM,CAAC,CAAC;gBAEzE,OALID,SAAS,IAAI,CAAC,CAAC,WAAW,EAAEC,KAAK,eAAe,CAAC;qBAFjDD,SAAS,IAAI,CAAC,CAAC,eAAe,EAAEC,KAAK,wCAAwC,CAAC;YAQtF;YACA,IAAID,SAAS,MAAM,GAAG,GAClB,OAAOV,OAAO,IAAI,CAAC,IAAIC,wBAAwBS,SAAS,IAAI,CAAC;YAGjEJ,aAAaQ,mBAAmBf,OAAO,IAAI,CAAC,UAAU,EAAED,OAAO,MAAM;QACzE,EAAE,OAAOK,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,OAAOL,OAAO,KAAK;gBAAE,UAAUA,OAAO,QAAQ;YAAC,GAC7D;YAEJ,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QACnD;QAEA,IAAI;YACA,MAAMc,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACjB,OAAO,gBAAgB,EAAE;gBAAEQ;YAAW;YACnF,IAAIS,OAAO,MAAM,IAAI;gBAEjB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBACI,KAAKC,eAAeD,OAAO,KAAK,IAAIA,OAAO,KAAK,CAAC,MAAM,GAAGA,OAAO,KAAK;oBACtE,OAAOjB,OAAO,KAAK;oBACnB,UAAUA,OAAO,QAAQ;gBAC7B,GACA;gBAEJ,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;YACnD;QACJ,EAAE,OAAOE,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,OAAOL,OAAO,KAAK;gBAAE,UAAUA,OAAO,QAAQ;YAAC,GAC7D;YAEJ,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QACnD;QAEA,OAAOD,OAAO,EAAE,CAAC;YAAE,SAASI;QAAM;IACtC;AACJ;AAEO,MAAMa,2BAA2BC,mBAAmB,oBAAoB,CAAC;IAC5E,gBAAgB3B;IAChB,cAAc;QAAC4B;QAAoBC;QAAcC;QAAmBC;KAAO;AAC/E"}

package/features/target/WbPageReviewTargetFolderChain.d.ts

@@ -0,0 +1,22 @@
+import { ReviewTargetFolderChain } from "@webiny/api-workflows/features/review/ReviewTargetFolderChain/index.js";
+import { GetFolderRepository } from "@webiny/api-aco/features/folder/GetFolder/abstractions.js";
+import { GetAncestorsUseCase } from "@webiny/api-aco/features/folder/GetAncestors/index.js";
+/**
+ * The folder of a `wb.page` target and its ancestors, nearest first, for the routing rules'
+ * folder condition (spec 6, R113, R114). Read through ACO's repository, which applies no
+ * folder-level permissions (the folder model is private with `authorization: false`): routing
+ * matches the folder tree, not what the requester may see. Read at step reach, so a moved parent
+ * counts. A missing folder, a folder of another type and a failed read throw; the engine falls
+ * through to the pool (R116).
+ */
+declare class WbPageReviewTargetFolderChainImpl implements ReviewTargetFolderChain.Interface {
+    private getFolder;
+    private getAncestors;
+    constructor(getFolder: GetFolderRepository.Interface, getAncestors: GetAncestorsUseCase.Interface);
+    canHandle(model: string): boolean;
+    listFolderChainIds(params: ReviewTargetFolderChain.Params): Promise<string[]>;
+}
+export declare const WbPageReviewTargetFolderChain: typeof WbPageReviewTargetFolderChainImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/review/ReviewTargetFolderChain/abstractions").IReviewTargetFolderChain>;
+};
+export {};

package/features/target/WbPageReviewTargetFolderChain.js

@@ -0,0 +1,34 @@
+import { ReviewTargetFolderChain } from "@webiny/api-workflows/features/review/ReviewTargetFolderChain/index.js";
+import { GetFolderRepository } from "@webiny/api-aco/features/folder/GetFolder/abstractions.js";
+import { GetAncestorsUseCase } from "@webiny/api-aco/features/folder/GetAncestors/index.js";
+import { WB_PAGE_FOLDER_TYPE, WB_PAGE_NAMESPACE } from "../../constants.js";
+class WbPageReviewTargetFolderChainImpl {
+    constructor(getFolder, getAncestors){
+        this.getFolder = getFolder;
+        this.getAncestors = getAncestors;
+    }
+    canHandle(model) {
+        return model === WB_PAGE_NAMESPACE;
+    }
+    async listFolderChainIds(params) {
+        if (!params.folderId || params.folderId.includes("#")) throw new Error(`"${params.folderId}" is not a valid folder id.`);
+        const folder = await this.getFolder.execute(params.folderId);
+        if (folder.isFail()) throw folder.error;
+        if (folder.value.type !== WB_PAGE_FOLDER_TYPE) throw new Error(`Folder "${params.folderId}" is not a Website Builder page folder.`);
+        const ancestors = await this.getAncestors.execute({
+            folder: folder.value
+        });
+        if (ancestors.isFail()) throw ancestors.error;
+        return ancestors.value.map((item)=>item.id);
+    }
+}
+const WbPageReviewTargetFolderChain = ReviewTargetFolderChain.createImplementation({
+    implementation: WbPageReviewTargetFolderChainImpl,
+    dependencies: [
+        GetFolderRepository,
+        GetAncestorsUseCase
+    ]
+});
+export { WbPageReviewTargetFolderChain };
+
+//# sourceMappingURL=WbPageReviewTargetFolderChain.js.map

package/features/target/WbPageReviewTargetFolderChain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewTargetFolderChain.js","sources":["../../../src/features/target/WbPageReviewTargetFolderChain.ts"],"sourcesContent":["import { ReviewTargetFolderChain } from \"@webiny/api-workflows/features/review/ReviewTargetFolderChain/index.js\";\nimport { GetFolderRepository } from \"@webiny/api-aco/features/folder/GetFolder/abstractions.js\";\nimport { GetAncestorsUseCase } from \"@webiny/api-aco/features/folder/GetAncestors/index.js\";\nimport { WB_PAGE_FOLDER_TYPE, WB_PAGE_NAMESPACE } from \"~/constants.js\";\n\n/**\n * The folder of a `wb.page` target and its ancestors, nearest first, for the routing rules'\n * folder condition (spec 6, R113, R114). Read through ACO's repository, which applies no\n * folder-level permissions (the folder model is private with `authorization: false`): routing\n * matches the folder tree, not what the requester may see. Read at step reach, so a moved parent\n * counts. A missing folder, a folder of another type and a failed read throw; the engine falls\n * through to the pool (R116).\n */\nclass WbPageReviewTargetFolderChainImpl implements ReviewTargetFolderChain.Interface {\n    public constructor(\n        private getFolder: GetFolderRepository.Interface,\n        private getAncestors: GetAncestorsUseCase.Interface\n    ) {}\n\n    public canHandle(model: string): boolean {\n        return model === WB_PAGE_NAMESPACE;\n    }\n\n    public async listFolderChainIds(params: ReviewTargetFolderChain.Params): Promise<string[]> {\n        // Folder ids are plain entry ids; the repository would read `<id>#<n>` as a revision.\n        if (!params.folderId || params.folderId.includes(\"#\")) {\n            throw new Error(`\"${params.folderId}\" is not a valid folder id.`);\n        }\n\n        const folder = await this.getFolder.execute(params.folderId);\n        if (folder.isFail()) {\n            throw folder.error;\n        }\n        if (folder.value.type !== WB_PAGE_FOLDER_TYPE) {\n            throw new Error(`Folder \"${params.folderId}\" is not a Website Builder page folder.`);\n        }\n\n        // The folder itself first, then its parents up to the root level.\n        const ancestors = await this.getAncestors.execute({ folder: folder.value });\n        if (ancestors.isFail()) {\n            throw ancestors.error;\n        }\n        return ancestors.value.map(item => item.id);\n    }\n}\n\nexport const WbPageReviewTargetFolderChain = ReviewTargetFolderChain.createImplementation({\n    implementation: WbPageReviewTargetFolderChainImpl,\n    dependencies: [GetFolderRepository, GetAncestorsUseCase]\n});\n"],"names":["WbPageReviewTargetFolderChainImpl","getFolder","getAncestors","model","WB_PAGE_NAMESPACE","params","Error","folder","WB_PAGE_FOLDER_TYPE","ancestors","item","WbPageReviewTargetFolderChain","ReviewTargetFolderChain","GetFolderRepository","GetAncestorsUseCase"],"mappings":";;;;AAaA,MAAMA;IACF,YACYC,SAAwC,EACxCC,YAA2C,CACrD;aAFUD,SAAS,GAATA;aACAC,YAAY,GAAZA;IACT;IAEI,UAAUC,KAAa,EAAW;QACrC,OAAOA,UAAUC;IACrB;IAEA,MAAa,mBAAmBC,MAAsC,EAAqB;QAEvF,IAAI,CAACA,OAAO,QAAQ,IAAIA,OAAO,QAAQ,CAAC,QAAQ,CAAC,MAC7C,MAAM,IAAIC,MAAM,CAAC,CAAC,EAAED,OAAO,QAAQ,CAAC,2BAA2B,CAAC;QAGpE,MAAME,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF,OAAO,QAAQ;QAC3D,IAAIE,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;QAEtB,IAAIA,OAAO,KAAK,CAAC,IAAI,KAAKC,qBACtB,MAAM,IAAIF,MAAM,CAAC,QAAQ,EAAED,OAAO,QAAQ,CAAC,uCAAuC,CAAC;QAIvF,MAAMI,YAAY,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YAAE,QAAQF,OAAO,KAAK;QAAC;QACzE,IAAIE,UAAU,MAAM,IAChB,MAAMA,UAAU,KAAK;QAEzB,OAAOA,UAAU,KAAK,CAAC,GAAG,CAACC,CAAAA,OAAQA,KAAK,EAAE;IAC9C;AACJ;AAEO,MAAMC,gCAAgCC,wBAAwB,oBAAoB,CAAC;IACtF,gBAAgBZ;IAChB,cAAc;QAACa;QAAqBC;KAAoB;AAC5D"}