@webiny/api-website-builder-workflows 0.0.0-unstable.9f53ea597d → 0.0.0-unstable.a85ef555b2

package/features/target/WbPageReviewTargetLink.d.ts

@@ -0,0 +1,17 @@
+import { ReviewTargetLink } from "@webiny/api-workflows/features/notifications/ReviewTargetLink/index.js";
+/**
+ * The `wb.page` admin link of a review's content (R195, D133). It mirrors the admin route
+ * `WebsiteBuilder/Pages/Editor` in `packages/app-website-builder/src/routes.ts`
+ * (`/website-builder/pages/editor/:id`), where `:id` is the page revision id. That file lives in a
+ * client package the API cannot import, so a route change there must be mirrored here. The
+ * revision id carries a `#`, which `encodeURIComponent` turns into `%23`. The path has no host
+ * and no tenant: `ReviewTargetLinkService` adds both.
+ */
+declare class WbPageReviewTargetLinkImpl implements ReviewTargetLink.Interface {
+    canLink(model: string): boolean;
+    getPath(params: ReviewTargetLink.Params): string;
+}
+export declare const WbPageReviewTargetLink: typeof WbPageReviewTargetLinkImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/notifications/ReviewTargetLink/abstractions").IReviewTargetLink>;
+};
+export {};

package/features/target/WbPageReviewTargetLink.js

@@ -0,0 +1,17 @@
+import { ReviewTargetLink } from "@webiny/api-workflows/features/notifications/ReviewTargetLink/index.js";
+import { WB_PAGE_NAMESPACE } from "../../constants.js";
+class WbPageReviewTargetLinkImpl {
+    canLink(model) {
+        return model === WB_PAGE_NAMESPACE;
+    }
+    getPath(params) {
+        return `/website-builder/pages/editor/${encodeURIComponent(params.targetRevisionId)}`;
+    }
+}
+const WbPageReviewTargetLink = ReviewTargetLink.createImplementation({
+    implementation: WbPageReviewTargetLinkImpl,
+    dependencies: []
+});
+export { WbPageReviewTargetLink };
+
+//# sourceMappingURL=WbPageReviewTargetLink.js.map

package/features/target/WbPageReviewTargetLink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewTargetLink.js","sources":["../../../src/features/target/WbPageReviewTargetLink.ts"],"sourcesContent":["import { ReviewTargetLink } from \"@webiny/api-workflows/features/notifications/ReviewTargetLink/index.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\n\n/**\n * The `wb.page` admin link of a review's content (R195, D133). It mirrors the admin route\n * `WebsiteBuilder/Pages/Editor` in `packages/app-website-builder/src/routes.ts`\n * (`/website-builder/pages/editor/:id`), where `:id` is the page revision id. That file lives in a\n * client package the API cannot import, so a route change there must be mirrored here. The\n * revision id carries a `#`, which `encodeURIComponent` turns into `%23`. The path has no host\n * and no tenant: `ReviewTargetLinkService` adds both.\n */\nclass WbPageReviewTargetLinkImpl implements ReviewTargetLink.Interface {\n    public canLink(model: string): boolean {\n        return model === WB_PAGE_NAMESPACE;\n    }\n\n    public getPath(params: ReviewTargetLink.Params): string {\n        return `/website-builder/pages/editor/${encodeURIComponent(params.targetRevisionId)}`;\n    }\n}\n\nexport const WbPageReviewTargetLink = ReviewTargetLink.createImplementation({\n    implementation: WbPageReviewTargetLinkImpl,\n    dependencies: []\n});\n"],"names":["WbPageReviewTargetLinkImpl","model","WB_PAGE_NAMESPACE","params","encodeURIComponent","WbPageReviewTargetLink","ReviewTargetLink"],"mappings":";;AAWA,MAAMA;IACK,QAAQC,KAAa,EAAW;QACnC,OAAOA,UAAUC;IACrB;IAEO,QAAQC,MAA+B,EAAU;QACpD,OAAO,CAAC,8BAA8B,EAAEC,mBAAmBD,OAAO,gBAAgB,GAAG;IACzF;AACJ;AAEO,MAAME,yBAAyBC,iBAAiB,oBAAoB,CAAC;IACxE,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/target/WbPageReviewTargetLoader.d.ts

@@ -0,0 +1,13 @@
+import { ReviewTargetLoader } from "@webiny/api-workflows/features/review/ReviewTargetLoader/index.js";
+import { WbPageTargetReader } from "./WbPageTargetReader/index.js";
+/** Loads `wb.page` targets for `RequestReviewUseCase` (spec 9.3). */
+declare class WbPageReviewTargetLoaderImpl implements ReviewTargetLoader.Interface {
+    private targets;
+    constructor(targets: WbPageTargetReader.Interface);
+    canLoad(model: string): boolean;
+    load(params: ReviewTargetLoader.LoadParams): Promise<ReviewTargetLoader.Target | null>;
+}
+export declare const WbPageReviewTargetLoader: typeof WbPageReviewTargetLoaderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/review/ReviewTargetLoader/abstractions.js").IReviewTargetLoader>;
+};
+export {};

package/features/target/WbPageReviewTargetLoader.js

@@ -0,0 +1,29 @@
+import { ReviewTargetLoader } from "@webiny/api-workflows/features/review/ReviewTargetLoader/index.js";
+import { WB_PAGE_NAMESPACE } from "../../constants.js";
+import { WbPageTargetReader } from "./WbPageTargetReader/index.js";
+import { toWbPageReviewTarget } from "./toWbPageReviewTarget.js";
+class WbPageReviewTargetLoaderImpl {
+    constructor(targets){
+        this.targets = targets;
+    }
+    canLoad(model) {
+        return model === WB_PAGE_NAMESPACE;
+    }
+    async load(params) {
+        const target = await this.targets.read({
+            model: params.model,
+            targetRevisionId: params.targetRevisionId
+        });
+        if (!target || target.page.entryId !== params.targetId) return null;
+        return toWbPageReviewTarget(target);
+    }
+}
+const WbPageReviewTargetLoader = ReviewTargetLoader.createImplementation({
+    implementation: WbPageReviewTargetLoaderImpl,
+    dependencies: [
+        WbPageTargetReader
+    ]
+});
+export { WbPageReviewTargetLoader };
+
+//# sourceMappingURL=WbPageReviewTargetLoader.js.map

package/features/target/WbPageReviewTargetLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewTargetLoader.js","sources":["../../../src/features/target/WbPageReviewTargetLoader.ts"],"sourcesContent":["import { ReviewTargetLoader } from \"@webiny/api-workflows/features/review/ReviewTargetLoader/index.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\nimport { WbPageTargetReader } from \"./WbPageTargetReader/index.js\";\nimport { toWbPageReviewTarget } from \"./toWbPageReviewTarget.js\";\n\n/** Loads `wb.page` targets for `RequestReviewUseCase` (spec 9.3). */\nclass WbPageReviewTargetLoaderImpl implements ReviewTargetLoader.Interface {\n    public constructor(private targets: WbPageTargetReader.Interface) {}\n\n    public canLoad(model: string): boolean {\n        return model === WB_PAGE_NAMESPACE;\n    }\n\n    public async load(\n        params: ReviewTargetLoader.LoadParams\n    ): Promise<ReviewTargetLoader.Target | null> {\n        const target = await this.targets.read({\n            model: params.model,\n            targetRevisionId: params.targetRevisionId\n        });\n        if (!target || target.page.entryId !== params.targetId) {\n            return null;\n        }\n        return toWbPageReviewTarget(target);\n    }\n}\n\nexport const WbPageReviewTargetLoader = ReviewTargetLoader.createImplementation({\n    implementation: WbPageReviewTargetLoaderImpl,\n    dependencies: [WbPageTargetReader]\n});\n"],"names":["WbPageReviewTargetLoaderImpl","targets","model","WB_PAGE_NAMESPACE","params","target","toWbPageReviewTarget","WbPageReviewTargetLoader","ReviewTargetLoader","WbPageTargetReader"],"mappings":";;;;AAMA,MAAMA;IACF,YAA2BC,OAAqC,CAAE;aAAvCA,OAAO,GAAPA;IAAwC;IAE5D,QAAQC,KAAa,EAAW;QACnC,OAAOA,UAAUC;IACrB;IAEA,MAAa,KACTC,MAAqC,EACI;QACzC,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YACnC,OAAOD,OAAO,KAAK;YACnB,kBAAkBA,OAAO,gBAAgB;QAC7C;QACA,IAAI,CAACC,UAAUA,OAAO,IAAI,CAAC,OAAO,KAAKD,OAAO,QAAQ,EAClD,OAAO;QAEX,OAAOE,qBAAqBD;IAChC;AACJ;AAEO,MAAME,2BAA2BC,mBAAmB,oBAAoB,CAAC;IAC5E,gBAAgBR;IAChB,cAAc;QAACS;KAAmB;AACtC"}

package/features/target/WbPageReviewTargetReadAccess.d.ts

@@ -0,0 +1,33 @@
+import { ReviewTargetReadAccess } from "@webiny/api-workflows/features/review/ReviewTargetReadAccess/index.js";
+import { CandidateReadAccess } from "@webiny/api-workflows/features/identity/CandidateReadAccess/index.js";
+import { CandidateFolderReadRules } from "@webiny/api-headless-cms-workflows/features/target/CandidateFolderReadRules/index.js";
+import { WbPageTargetReader } from "./WbPageTargetReader/index.js";
+import { WbPageAccess } from "./WbPageAccess/index.js";
+/**
+ * `filterReadableUsers` for pages (D61, D133, R48): the page and the folder's permission record
+ * are read once per call, as the current identity (Q79); only the WB access check runs as each
+ * user, through `CandidateReadAccess` (R67). For a folder without a page (R121) only the
+ * folder-level check runs as each user.
+ *
+ * Contract: reach this only as the request identity, never from inside
+ * `withoutAuthorization`. The page model is read through `PageModelProvider`, which uses the CMS
+ * model cache (filled per tenant after access filtering), so a read without authorization would
+ * cache the unfiltered list for every later caller. `CandidateReadAccess` is the only place that
+ * changes identity for the check. Any failure, including a throwing target read, leaves the users
+ * out (fail closed, R50).
+ */
+declare class WbPageReviewTargetReadAccessImpl implements ReviewTargetReadAccess.Interface {
+    private targets;
+    private access;
+    private candidates;
+    private folderRules;
+    constructor(targets: WbPageTargetReader.Interface, access: WbPageAccess.Interface, candidates: CandidateReadAccess.Interface, folderRules: CandidateFolderReadRules.Interface);
+    canHandle(model: string): boolean;
+    filterReadableUsers(params: ReviewTargetReadAccess.UsersParams): Promise<string[]>;
+    /** The page revision, or the folder without a page (R121); `null` when nothing is readable. */
+    private readSubject;
+}
+export declare const WbPageReviewTargetReadAccess: typeof WbPageReviewTargetReadAccessImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/review/ReviewTargetReadAccess/abstractions.js").IReviewTargetReadAccess>;
+};
+export {};

package/features/target/WbPageReviewTargetReadAccess.js

@@ -0,0 +1,72 @@
+import { ROOT_FOLDER } from "@webiny/api-website-builder/constants.js";
+import { ReviewTargetReadAccess } from "@webiny/api-workflows/features/review/ReviewTargetReadAccess/index.js";
+import { CandidateReadAccess } from "@webiny/api-workflows/features/identity/CandidateReadAccess/index.js";
+import { CandidateFolderReadRules } from "@webiny/api-headless-cms-workflows/features/target/CandidateFolderReadRules/index.js";
+import { WB_PAGE_NAMESPACE } from "../../constants.js";
+import { WbPageTargetReader } from "./WbPageTargetReader/index.js";
+import { WbPageAccess } from "./WbPageAccess/index.js";
+class WbPageReviewTargetReadAccessImpl {
+    constructor(targets, access, candidates, folderRules){
+        this.targets = targets;
+        this.access = access;
+        this.candidates = candidates;
+        this.folderRules = folderRules;
+    }
+    canHandle(model) {
+        return model === WB_PAGE_NAMESPACE;
+    }
+    async filterReadableUsers(params) {
+        if (0 === params.users.length || params.model !== WB_PAGE_NAMESPACE) return [];
+        let subject;
+        try {
+            subject = await this.readSubject(params);
+        } catch  {
+            return [];
+        }
+        if (!subject) return [];
+        const { check, folderId } = subject;
+        let folderRule;
+        if (folderId && folderId !== ROOT_FOLDER) folderRule = this.folderRules.create({
+            folderId,
+            users: params.users
+        });
+        const readable = [];
+        for (const user of params.users){
+            if (void 0 !== params.limit && readable.length >= params.limit) break;
+            const canRead = await this.candidates.canUserRead(user, ()=>check(folderRule));
+            if (canRead) readable.push(user.id);
+        }
+        return readable;
+    }
+    async readSubject(params) {
+        if ("folder" === params.read.type) {
+            const { folderId } = params.read;
+            return {
+                check: (folderRule)=>this.access.canReadInFolder(folderId, folderRule),
+                folderId
+            };
+        }
+        const { targetId } = params.read;
+        const target = await this.targets.read({
+            model: params.model,
+            targetRevisionId: params.read.targetRevisionId
+        });
+        if (!target || target.page.entryId !== targetId) return null;
+        return {
+            check: (folderRule)=>this.access.canRead(target, folderRule),
+            folderId: target.page.location.folderId ?? null
+        };
+    }
+}
+const WbPageReviewTargetReadAccess = ReviewTargetReadAccess.createImplementation({
+    implementation: WbPageReviewTargetReadAccessImpl,
+    dependencies: [
+        WbPageTargetReader,
+        WbPageAccess,
+        CandidateReadAccess,
+        CandidateFolderReadRules
+    ]
+});
+export { WbPageReviewTargetReadAccess };
+
+//# sourceMappingURL=WbPageReviewTargetReadAccess.js.map

package/features/target/WbPageReviewTargetReadAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewTargetReadAccess.js","sources":["../../../src/features/target/WbPageReviewTargetReadAccess.ts"],"sourcesContent":["import { ROOT_FOLDER } from \"@webiny/api-website-builder/constants.js\";\nimport { ReviewTargetReadAccess } from \"@webiny/api-workflows/features/review/ReviewTargetReadAccess/index.js\";\nimport { CandidateReadAccess } from \"@webiny/api-workflows/features/identity/CandidateReadAccess/index.js\";\nimport { CandidateFolderReadRules } from \"@webiny/api-headless-cms-workflows/features/target/CandidateFolderReadRules/index.js\";\nimport type { FolderReadRule } from \"@webiny/api-headless-cms-workflows/features/target/FolderReadRule.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\nimport { WbPageTargetReader } from \"./WbPageTargetReader/index.js\";\nimport { WbPageAccess } from \"./WbPageAccess/index.js\";\n\n/** What every candidate's check needs, read once per call as the current identity. */\ninterface CandidateReadSubject {\n    /** The candidate check, run as the candidate. */\n    check: (folderRule: FolderReadRule | undefined) => Promise<boolean>;\n    /** The folder a rule is needed for; `null` for the root folder. */\n    folderId: string | null;\n}\n\n/**\n * `filterReadableUsers` for pages (D61, D133, R48): the page and the folder's permission record\n * are read once per call, as the current identity (Q79); only the WB access check runs as each\n * user, through `CandidateReadAccess` (R67). For a folder without a page (R121) only the\n * folder-level check runs as each user.\n *\n * Contract: reach this only as the request identity, never from inside\n * `withoutAuthorization`. The page model is read through `PageModelProvider`, which uses the CMS\n * model cache (filled per tenant after access filtering), so a read without authorization would\n * cache the unfiltered list for every later caller. `CandidateReadAccess` is the only place that\n * changes identity for the check. Any failure, including a throwing target read, leaves the users\n * out (fail closed, R50).\n */\nclass WbPageReviewTargetReadAccessImpl implements ReviewTargetReadAccess.Interface {\n    public constructor(\n        private targets: WbPageTargetReader.Interface,\n        private access: WbPageAccess.Interface,\n        private candidates: CandidateReadAccess.Interface,\n        private folderRules: CandidateFolderReadRules.Interface\n    ) {}\n\n    public canHandle(model: string): boolean {\n        return model === WB_PAGE_NAMESPACE;\n    }\n\n    public async filterReadableUsers(\n        params: ReviewTargetReadAccess.UsersParams\n    ): Promise<string[]> {\n        if (params.users.length === 0 || params.model !== WB_PAGE_NAMESPACE) {\n            return [];\n        }\n        let subject: CandidateReadSubject | null;\n        try {\n            subject = await this.readSubject(params);\n        } catch {\n            return [];\n        }\n        if (!subject) {\n            return [];\n        }\n        const { check, folderId } = subject;\n        let folderRule: FolderReadRule | undefined;\n        if (folderId && folderId !== ROOT_FOLDER) {\n            folderRule = this.folderRules.create({ folderId, users: params.users });\n        }\n\n        const readable: string[] = [];\n        // One user at a time, as that user: the check reads nothing, but each user's own\n        // permissions load once (cached per identity), so a limited call stops early.\n        for (const user of params.users) {\n            if (params.limit !== undefined && readable.length >= params.limit) {\n                break;\n            }\n            // oxlint-disable-next-line no-await-in-loop -- one user at a time, as that user; a limited call stops early.\n            const canRead = await this.candidates.canUserRead(user, () => check(folderRule));\n            if (canRead) {\n                readable.push(user.id);\n            }\n        }\n        return readable;\n    }\n\n    /** The page revision, or the folder without a page (R121); `null` when nothing is readable. */\n    private async readSubject(\n        params: ReviewTargetReadAccess.UsersParams\n    ): Promise<CandidateReadSubject | null> {\n        if (params.read.type === \"folder\") {\n            const { folderId } = params.read;\n            return {\n                check: folderRule => this.access.canReadInFolder(folderId, folderRule),\n                folderId\n            };\n        }\n        const { targetId } = params.read;\n        const target = await this.targets.read({\n            model: params.model,\n            targetRevisionId: params.read.targetRevisionId\n        });\n        if (!target || target.page.entryId !== targetId) {\n            return null;\n        }\n        return {\n            check: folderRule => this.access.canRead(target, folderRule),\n            folderId: target.page.location.folderId ?? null\n        };\n    }\n}\n\nexport const WbPageReviewTargetReadAccess = ReviewTargetReadAccess.createImplementation({\n    implementation: WbPageReviewTargetReadAccessImpl,\n    dependencies: [WbPageTargetReader, WbPageAccess, CandidateReadAccess, CandidateFolderReadRules]\n});\n"],"names":["WbPageReviewTargetReadAccessImpl","targets","access","candidates","folderRules","model","WB_PAGE_NAMESPACE","params","subject","check","folderId","folderRule","ROOT_FOLDER","readable","user","undefined","canRead","targetId","target","WbPageReviewTargetReadAccess","ReviewTargetReadAccess","WbPageTargetReader","WbPageAccess","CandidateReadAccess","CandidateFolderReadRules"],"mappings":";;;;;;;AA8BA,MAAMA;IACF,YACYC,OAAqC,EACrCC,MAA8B,EAC9BC,UAAyC,EACzCC,WAA+C,CACzD;aAJUH,OAAO,GAAPA;aACAC,MAAM,GAANA;aACAC,UAAU,GAAVA;aACAC,WAAW,GAAXA;IACT;IAEI,UAAUC,KAAa,EAAW;QACrC,OAAOA,UAAUC;IACrB;IAEA,MAAa,oBACTC,MAA0C,EACzB;QACjB,IAAIA,AAAwB,MAAxBA,OAAO,KAAK,CAAC,MAAM,IAAUA,OAAO,KAAK,KAAKD,mBAC9C,OAAO,EAAE;QAEb,IAAIE;QACJ,IAAI;YACAA,UAAU,MAAM,IAAI,CAAC,WAAW,CAACD;QACrC,EAAE,OAAM;YACJ,OAAO,EAAE;QACb;QACA,IAAI,CAACC,SACD,OAAO,EAAE;QAEb,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5B,IAAIG;QACJ,IAAID,YAAYA,aAAaE,aACzBD,aAAa,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;YAAED;YAAU,OAAOH,OAAO,KAAK;QAAC;QAGzE,MAAMM,WAAqB,EAAE;QAG7B,KAAK,MAAMC,QAAQP,OAAO,KAAK,CAAE;YAC7B,IAAIA,AAAiBQ,WAAjBR,OAAO,KAAK,IAAkBM,SAAS,MAAM,IAAIN,OAAO,KAAK,EAC7D;YAGJ,MAAMS,UAAU,MAAM,IAAI,CAAC,UAAU,CAAC,WAAW,CAACF,MAAM,IAAML,MAAME;YACpE,IAAIK,SACAH,SAAS,IAAI,CAACC,KAAK,EAAE;QAE7B;QACA,OAAOD;IACX;IAGA,MAAc,YACVN,MAA0C,EACN;QACpC,IAAIA,AAAqB,aAArBA,OAAO,IAAI,CAAC,IAAI,EAAe;YAC/B,MAAM,EAAEG,QAAQ,EAAE,GAAGH,OAAO,IAAI;YAChC,OAAO;gBACH,OAAOI,CAAAA,aAAc,IAAI,CAAC,MAAM,CAAC,eAAe,CAACD,UAAUC;gBAC3DD;YACJ;QACJ;QACA,MAAM,EAAEO,QAAQ,EAAE,GAAGV,OAAO,IAAI;QAChC,MAAMW,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YACnC,OAAOX,OAAO,KAAK;YACnB,kBAAkBA,OAAO,IAAI,CAAC,gBAAgB;QAClD;QACA,IAAI,CAACW,UAAUA,OAAO,IAAI,CAAC,OAAO,KAAKD,UACnC,OAAO;QAEX,OAAO;YACH,OAAON,CAAAA,aAAc,IAAI,CAAC,MAAM,CAAC,OAAO,CAACO,QAAQP;YACjD,UAAUO,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI;QAC/C;IACJ;AACJ;AAEO,MAAMC,+BAA+BC,uBAAuB,oBAAoB,CAAC;IACpF,gBAAgBpB;IAChB,cAAc;QAACqB;QAAoBC;QAAcC;QAAqBC;KAAyB;AACnG"}

package/features/target/WbPageReviewTargetSync.d.ts

@@ -0,0 +1,23 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { UpdateEntrySystemUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntrySystem/index.js";
+import { PageModelProvider } from "@webiny/api-website-builder/domain/page/abstractions.js";
+import { ReviewTargetSync } from "@webiny/api-workflows/features/review/ReviewTargetSync/index.js";
+/**
+ * Writes `system.workflow` on the page revision (spec 4.5, D52, R63). The page model is read as the
+ * current identity (A19); only the system write runs without authorization, so a reviewer with
+ * read access can move the review on. Pages are CMS entries, so this is the same
+ * `UpdateEntrySystemUseCase` the CMS adapter uses; it does not publish `EntryBeforeUpdate` (D62).
+ * Any throw becomes a failed result, so the review stays saved (R16).
+ */
+declare class WbPageReviewTargetSyncImpl implements ReviewTargetSync.Interface {
+    private identityContext;
+    private pageModelProvider;
+    private updateEntrySystem;
+    constructor(identityContext: IdentityContext.Interface, pageModelProvider: PageModelProvider.Interface, updateEntrySystem: UpdateEntrySystemUseCase.Interface);
+    canSync(model: string): boolean;
+    sync(params: ReviewTargetSync.Params): ReviewTargetSync.Return;
+}
+export declare const WbPageReviewTargetSync: typeof WbPageReviewTargetSyncImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/review/ReviewTargetSync/abstractions").IReviewTargetSync>;
+};
+export {};

package/features/target/WbPageReviewTargetSync.js

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { UpdateEntrySystemUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntrySystem/index.js";
+import { PageModelProvider } from "@webiny/api-website-builder/domain/page/abstractions.js";
+import { ReviewTargetSync } from "@webiny/api-workflows/features/review/ReviewTargetSync/index.js";
+import { WB_PAGE_NAMESPACE } from "../../constants.js";
+class WbPageReviewTargetSyncImpl {
+    constructor(identityContext, pageModelProvider, updateEntrySystem){
+        this.identityContext = identityContext;
+        this.pageModelProvider = pageModelProvider;
+        this.updateEntrySystem = updateEntrySystem;
+    }
+    canSync(model) {
+        return model === WB_PAGE_NAMESPACE;
+    }
+    async sync(params) {
+        try {
+            const model = await this.pageModelProvider.get();
+            const updated = await this.identityContext.withoutAuthorization(()=>this.updateEntrySystem.execute(model, params.review.targetRevisionId, {
+                    workflow: params.systemWorkflow
+                }));
+            if (updated.isFail()) return Result.fail(updated.error);
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+}
+const WbPageReviewTargetSync = ReviewTargetSync.createImplementation({
+    implementation: WbPageReviewTargetSyncImpl,
+    dependencies: [
+        IdentityContext,
+        PageModelProvider,
+        UpdateEntrySystemUseCase
+    ]
+});
+export { WbPageReviewTargetSync };
+
+//# sourceMappingURL=WbPageReviewTargetSync.js.map

package/features/target/WbPageReviewTargetSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageReviewTargetSync.js","sources":["../../../src/features/target/WbPageReviewTargetSync.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { UpdateEntrySystemUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntrySystem/index.js\";\nimport { PageModelProvider } from \"@webiny/api-website-builder/domain/page/abstractions.js\";\nimport { ReviewTargetSync } from \"@webiny/api-workflows/features/review/ReviewTargetSync/index.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\n\n/**\n * Writes `system.workflow` on the page revision (spec 4.5, D52, R63). The page model is read as the\n * current identity (A19); only the system write runs without authorization, so a reviewer with\n * read access can move the review on. Pages are CMS entries, so this is the same\n * `UpdateEntrySystemUseCase` the CMS adapter uses; it does not publish `EntryBeforeUpdate` (D62).\n * Any throw becomes a failed result, so the review stays saved (R16).\n */\nclass WbPageReviewTargetSyncImpl implements ReviewTargetSync.Interface {\n    public constructor(\n        private identityContext: IdentityContext.Interface,\n        private pageModelProvider: PageModelProvider.Interface,\n        private updateEntrySystem: UpdateEntrySystemUseCase.Interface\n    ) {}\n\n    public canSync(model: string): boolean {\n        return model === WB_PAGE_NAMESPACE;\n    }\n\n    public async sync(params: ReviewTargetSync.Params): ReviewTargetSync.Return {\n        try {\n            const model = await this.pageModelProvider.get();\n            const updated = await this.identityContext.withoutAuthorization(() => {\n                return this.updateEntrySystem.execute(model, params.review.targetRevisionId, {\n                    workflow: params.systemWorkflow\n                });\n            });\n            if (updated.isFail()) {\n                return Result.fail(updated.error);\n            }\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(error instanceof Error ? error : new Error(String(error)));\n        }\n    }\n}\n\nexport const WbPageReviewTargetSync = ReviewTargetSync.createImplementation({\n    implementation: WbPageReviewTargetSyncImpl,\n    dependencies: [IdentityContext, PageModelProvider, UpdateEntrySystemUseCase]\n});\n"],"names":["WbPageReviewTargetSyncImpl","identityContext","pageModelProvider","updateEntrySystem","model","WB_PAGE_NAMESPACE","params","updated","Result","error","Error","String","WbPageReviewTargetSync","ReviewTargetSync","IdentityContext","PageModelProvider","UpdateEntrySystemUseCase"],"mappings":";;;;;;AAcA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,iBAA8C,EAC9CC,iBAAqD,CAC/D;aAHUF,eAAe,GAAfA;aACAC,iBAAiB,GAAjBA;aACAC,iBAAiB,GAAjBA;IACT;IAEI,QAAQC,KAAa,EAAW;QACnC,OAAOA,UAAUC;IACrB;IAEA,MAAa,KAAKC,MAA+B,EAA2B;QACxE,IAAI;YACA,MAAMF,QAAQ,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG;YAC9C,MAAMG,UAAU,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,IACrD,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACH,OAAOE,OAAO,MAAM,CAAC,gBAAgB,EAAE;oBACzE,UAAUA,OAAO,cAAc;gBACnC;YAEJ,IAAIC,QAAQ,MAAM,IACd,OAAOC,OAAO,IAAI,CAACD,QAAQ,KAAK;YAEpC,OAAOC,OAAO,EAAE;QACpB,EAAE,OAAOC,OAAO;YACZ,OAAOD,OAAO,IAAI,CAACC,iBAAiBC,QAAQD,QAAQ,IAAIC,MAAMC,OAAOF;QACzE;IACJ;AACJ;AAEO,MAAMG,yBAAyBC,iBAAiB,oBAAoB,CAAC;IACxE,gBAAgBb;IAChB,cAAc;QAACc;QAAiBC;QAAmBC;KAAyB;AAChF"}

package/features/target/WbPageTargetReader/WbPageTargetReader.d.ts

@@ -0,0 +1,20 @@
+import { GetRevisionByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js";
+import { GetEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntriesByIds/index.js";
+import { PageModelProvider } from "@webiny/api-website-builder/domain/page/abstractions.js";
+import { WbPageTargetReader as Abstraction } from "./abstractions.js";
+/**
+ * The page model is private (`authorization: false`), so `PageModelProvider` reads it for any
+ * identity as the current one; nothing reads models without authorization (A19).
+ */
+declare class WbPageTargetReaderImpl implements Abstraction.Interface {
+    private pageModelProvider;
+    private getRevisionById;
+    private getEntriesByIds;
+    constructor(pageModelProvider: PageModelProvider.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, getEntriesByIds: GetEntriesByIdsUseCase.Interface);
+    read(params: Abstraction.Params): Promise<Abstraction.Target | null>;
+    readMany(params: Abstraction.ManyParams): Promise<Abstraction.Target[]>;
+}
+export declare const WbPageTargetReader: typeof WbPageTargetReaderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IWbPageTargetReader>;
+};
+export {};

package/features/target/WbPageTargetReader/WbPageTargetReader.js

@@ -0,0 +1,51 @@
+import { GetRevisionByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js";
+import { GetEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntriesByIds/index.js";
+import { PageModelProvider } from "@webiny/api-website-builder/domain/page/abstractions.js";
+import { EntryToPageMapper } from "@webiny/api-website-builder/domain/page/EntryToPageMapper.js";
+import { WB_PAGE_NAMESPACE } from "../../../constants.js";
+import { WbPageTargetReader } from "./abstractions.js";
+const ENTRY_NOT_FOUND = "Cms/Entry/NotFound";
+class WbPageTargetReaderImpl {
+    constructor(pageModelProvider, getRevisionById, getEntriesByIds){
+        this.pageModelProvider = pageModelProvider;
+        this.getRevisionById = getRevisionById;
+        this.getEntriesByIds = getEntriesByIds;
+    }
+    async read(params) {
+        if (params.model !== WB_PAGE_NAMESPACE) return null;
+        const model = await this.pageModelProvider.get();
+        const entry = await this.getRevisionById.execute(model, params.targetRevisionId);
+        if (entry.isFail()) {
+            if (entry.error.code === ENTRY_NOT_FOUND) return null;
+            throw entry.error;
+        }
+        return {
+            model,
+            page: EntryToPageMapper.toPage(entry.value)
+        };
+    }
+    async readMany(params) {
+        if (params.model !== WB_PAGE_NAMESPACE || 0 === params.targetRevisionIds.length) return [];
+        const model = await this.pageModelProvider.get();
+        const revisionIds = [
+            ...new Set(params.targetRevisionIds)
+        ];
+        const entries = await this.getEntriesByIds.execute(model, revisionIds);
+        if (entries.isFail()) throw entries.error;
+        return entries.value.map((entry)=>({
+                model,
+                page: EntryToPageMapper.toPage(entry)
+            }));
+    }
+}
+const WbPageTargetReader_WbPageTargetReader = WbPageTargetReader.createImplementation({
+    implementation: WbPageTargetReaderImpl,
+    dependencies: [
+        PageModelProvider,
+        GetRevisionByIdUseCase,
+        GetEntriesByIdsUseCase
+    ]
+});
+export { WbPageTargetReader_WbPageTargetReader as WbPageTargetReader };
+
+//# sourceMappingURL=WbPageTargetReader.js.map

package/features/target/WbPageTargetReader/WbPageTargetReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageTargetReader/WbPageTargetReader.js","sources":["../../../../src/features/target/WbPageTargetReader/WbPageTargetReader.ts"],"sourcesContent":["import { GetRevisionByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js\";\nimport { GetEntriesByIdsUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntriesByIds/index.js\";\nimport { PageModelProvider } from \"@webiny/api-website-builder/domain/page/abstractions.js\";\nimport { EntryToPageMapper } from \"@webiny/api-website-builder/domain/page/EntryToPageMapper.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\nimport { WbPageTargetReader as Abstraction } from \"./abstractions.js\";\n\nconst ENTRY_NOT_FOUND = \"Cms/Entry/NotFound\";\n\n/**\n * The page model is private (`authorization: false`), so `PageModelProvider` reads it for any\n * identity as the current one; nothing reads models without authorization (A19).\n */\nclass WbPageTargetReaderImpl implements Abstraction.Interface {\n    public constructor(\n        private pageModelProvider: PageModelProvider.Interface,\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private getEntriesByIds: GetEntriesByIdsUseCase.Interface\n    ) {}\n\n    public async read(params: Abstraction.Params): Promise<Abstraction.Target | null> {\n        if (params.model !== WB_PAGE_NAMESPACE) {\n            return null;\n        }\n\n        const model = await this.pageModelProvider.get();\n        const entry = await this.getRevisionById.execute(model, params.targetRevisionId);\n        if (entry.isFail()) {\n            if (entry.error.code === ENTRY_NOT_FOUND) {\n                return null;\n            }\n            throw entry.error;\n        }\n\n        return { model, page: EntryToPageMapper.toPage(entry.value) };\n    }\n\n    public async readMany(params: Abstraction.ManyParams): Promise<Abstraction.Target[]> {\n        if (params.model !== WB_PAGE_NAMESPACE || params.targetRevisionIds.length === 0) {\n            return [];\n        }\n\n        const model = await this.pageModelProvider.get();\n        // One batch read for every revision (Q79); trashed revisions are left out.\n        const revisionIds = [...new Set(params.targetRevisionIds)];\n        const entries = await this.getEntriesByIds.execute(model, revisionIds);\n        if (entries.isFail()) {\n            throw entries.error;\n        }\n\n        return entries.value.map(entry => ({ model, page: EntryToPageMapper.toPage(entry) }));\n    }\n}\n\nexport const WbPageTargetReader = Abstraction.createImplementation({\n    implementation: WbPageTargetReaderImpl,\n    dependencies: [PageModelProvider, GetRevisionByIdUseCase, GetEntriesByIdsUseCase]\n});\n"],"names":["ENTRY_NOT_FOUND","WbPageTargetReaderImpl","pageModelProvider","getRevisionById","getEntriesByIds","params","WB_PAGE_NAMESPACE","model","entry","EntryToPageMapper","revisionIds","Set","entries","WbPageTargetReader","Abstraction","PageModelProvider","GetRevisionByIdUseCase","GetEntriesByIdsUseCase"],"mappings":";;;;;;AAOA,MAAMA,kBAAkB;AAMxB,MAAMC;IACF,YACYC,iBAA8C,EAC9CC,eAAiD,EACjDC,eAAiD,CAC3D;aAHUF,iBAAiB,GAAjBA;aACAC,eAAe,GAAfA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAa,KAAKC,MAA0B,EAAsC;QAC9E,IAAIA,OAAO,KAAK,KAAKC,mBACjB,OAAO;QAGX,MAAMC,QAAQ,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG;QAC9C,MAAMC,QAAQ,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACD,OAAOF,OAAO,gBAAgB;QAC/E,IAAIG,MAAM,MAAM,IAAI;YAChB,IAAIA,MAAM,KAAK,CAAC,IAAI,KAAKR,iBACrB,OAAO;YAEX,MAAMQ,MAAM,KAAK;QACrB;QAEA,OAAO;YAAED;YAAO,MAAME,kBAAkB,MAAM,CAACD,MAAM,KAAK;QAAE;IAChE;IAEA,MAAa,SAASH,MAA8B,EAAiC;QACjF,IAAIA,OAAO,KAAK,KAAKC,qBAAqBD,AAAoC,MAApCA,OAAO,iBAAiB,CAAC,MAAM,EACrE,OAAO,EAAE;QAGb,MAAME,QAAQ,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG;QAE9C,MAAMG,cAAc;eAAI,IAAIC,IAAIN,OAAO,iBAAiB;SAAE;QAC1D,MAAMO,UAAU,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACL,OAAOG;QAC1D,IAAIE,QAAQ,MAAM,IACd,MAAMA,QAAQ,KAAK;QAGvB,OAAOA,QAAQ,KAAK,CAAC,GAAG,CAACJ,CAAAA,QAAU;gBAAED;gBAAO,MAAME,kBAAkB,MAAM,CAACD;YAAO;IACtF;AACJ;AAEO,MAAMK,wCAAqBC,mBAAAA,oBAAgC,CAAC;IAC/D,gBAAgBb;IAChB,cAAc;QAACc;QAAmBC;QAAwBC;KAAuB;AACrF"}

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

@@ -0,0 +1,37 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { WbPage } from "@webiny/api-website-builder/domain/page/abstractions.js";
+export interface WbPageTargetReadParams {
+    /** Namespace id; only `wb.page` has targets here. */
+    model: string;
+    targetRevisionId: string;
+}
+export interface WbPageTargetsReadParams {
+    /** Namespace id; only `wb.page` has targets here. */
+    model: string;
+    targetRevisionIds: string[];
+}
+export interface WbPageTarget {
+    /** The CMS page model, for `UpdateEntrySystemUseCase`. */
+    model: CmsModel;
+    page: WbPage;
+}
+export interface IWbPageTargetReader {
+    /**
+     * Reads the page revision. `null` for another namespace or a missing revision; other failures
+     * are thrown. No access check: callers decide with `WbPageAccess`.
+     */
+    read(params: WbPageTargetReadParams): Promise<WbPageTarget | null>;
+    /**
+     * Reads many page revisions in one batch read, in no particular order. A missing (or trashed)
+     * revision is left out; `[]` for another namespace. Other failures are thrown. No access check.
+     */
+    readMany(params: WbPageTargetsReadParams): Promise<WbPageTarget[]>;
+}
+/** Loads a page revision for the `wb.page` adapter and wrappers (R47). */
+export declare const WbPageTargetReader: import("@webiny/di").Abstraction<IWbPageTargetReader>;
+export declare namespace WbPageTargetReader {
+    type Interface = IWbPageTargetReader;
+    type Params = WbPageTargetReadParams;
+    type ManyParams = WbPageTargetsReadParams;
+    type Target = WbPageTarget;
+}

package/features/target/WbPageTargetReader/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbPageTargetReader/abstractions.js","sources":["../../../../src/features/target/WbPageTargetReader/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { WbPage } from \"@webiny/api-website-builder/domain/page/abstractions.js\";\n\nexport interface WbPageTargetReadParams {\n    /** Namespace id; only `wb.page` has targets here. */\n    model: string;\n    targetRevisionId: string;\n}\n\nexport interface WbPageTargetsReadParams {\n    /** Namespace id; only `wb.page` has targets here. */\n    model: string;\n    targetRevisionIds: string[];\n}\n\nexport interface WbPageTarget {\n    /** The CMS page model, for `UpdateEntrySystemUseCase`. */\n    model: CmsModel;\n    page: WbPage;\n}\n\nexport interface IWbPageTargetReader {\n    /**\n     * Reads the page revision. `null` for another namespace or a missing revision; other failures\n     * are thrown. No access check: callers decide with `WbPageAccess`.\n     */\n    read(params: WbPageTargetReadParams): Promise<WbPageTarget | null>;\n    /**\n     * Reads many page revisions in one batch read, in no particular order. A missing (or trashed)\n     * revision is left out; `[]` for another namespace. Other failures are thrown. No access check.\n     */\n    readMany(params: WbPageTargetsReadParams): Promise<WbPageTarget[]>;\n}\n\n/** Loads a page revision for the `wb.page` adapter and wrappers (R47). */\nexport const WbPageTargetReader = createAbstraction<IWbPageTargetReader>(\"WbPageTargetReader\");\n\nexport namespace WbPageTargetReader {\n    export type Interface = IWbPageTargetReader;\n    export type Params = WbPageTargetReadParams;\n    export type ManyParams = WbPageTargetsReadParams;\n    export type Target = WbPageTarget;\n}\n"],"names":["WbPageTargetReader","createAbstraction"],"mappings":";AAoCO,MAAMA,qBAAqBC,kBAAuC"}

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

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

package/features/target/WbPageTargetReader/index.js

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

package/features/target/WbWorkflowModelParser.d.ts

@@ -0,0 +1,9 @@
+import { WorkflowModelParser } from "@webiny/api-workflows/features/model/WorkflowModelParser/index.js";
+/** The `wb.page` workflow model: the `wb` app and the page model's id (D15, D137, R113). */
+declare class WbWorkflowModelParserImpl implements WorkflowModelParser.Interface {
+    parse(model: string): WorkflowModelParser.Parsed | null;
+}
+export declare const WbWorkflowModelParser: typeof WbWorkflowModelParserImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/model/WorkflowModelParser/abstractions").IWorkflowModelParser>;
+};
+export {};

package/features/target/WbWorkflowModelParser.js

@@ -0,0 +1,18 @@
+import { WorkflowModelParser } from "@webiny/api-workflows/features/model/WorkflowModelParser/index.js";
+import { PAGE_MODEL_ID } from "@webiny/api-website-builder/domain/page/page.model.js";
+import { WB_PAGE_NAMESPACE } from "../../constants.js";
+class WbWorkflowModelParserImpl {
+    parse(model) {
+        return model === WB_PAGE_NAMESPACE ? {
+            app: "wb",
+            modelId: PAGE_MODEL_ID
+        } : null;
+    }
+}
+const WbWorkflowModelParser = WorkflowModelParser.createImplementation({
+    implementation: WbWorkflowModelParserImpl,
+    dependencies: []
+});
+export { WbWorkflowModelParser };
+
+//# sourceMappingURL=WbWorkflowModelParser.js.map

package/features/target/WbWorkflowModelParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/WbWorkflowModelParser.js","sources":["../../../src/features/target/WbWorkflowModelParser.ts"],"sourcesContent":["import { WorkflowModelParser } from \"@webiny/api-workflows/features/model/WorkflowModelParser/index.js\";\nimport { PAGE_MODEL_ID } from \"@webiny/api-website-builder/domain/page/page.model.js\";\nimport { WB_PAGE_NAMESPACE } from \"~/constants.js\";\n\n/** The `wb.page` workflow model: the `wb` app and the page model's id (D15, D137, R113). */\nclass WbWorkflowModelParserImpl implements WorkflowModelParser.Interface {\n    public parse(model: string): WorkflowModelParser.Parsed | null {\n        return model === WB_PAGE_NAMESPACE ? { app: \"wb\", modelId: PAGE_MODEL_ID } : null;\n    }\n}\n\nexport const WbWorkflowModelParser = WorkflowModelParser.createImplementation({\n    implementation: WbWorkflowModelParserImpl,\n    dependencies: []\n});\n"],"names":["WbWorkflowModelParserImpl","model","WB_PAGE_NAMESPACE","PAGE_MODEL_ID","WbWorkflowModelParser","WorkflowModelParser"],"mappings":";;;AAKA,MAAMA;IACK,MAAMC,KAAa,EAAqC;QAC3D,OAAOA,UAAUC,oBAAoB;YAAE,KAAK;YAAM,SAASC;QAAc,IAAI;IACjF;AACJ;AAEO,MAAMC,wBAAwBC,oBAAoB,oBAAoB,CAAC;IAC1E,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/features/target/feature.d.ts

@@ -0,0 +1,5 @@
+/** The `wb.page` target adapter (spec 9.3). */
+export declare const WbTargetFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/target/feature.js

@@ -0,0 +1,35 @@
+import { createFeature } from "@webiny/feature/api";
+import { WbPageReviewNamespace } from "./WbPageReviewNamespace.js";
+import { WbPageTargetReader } from "./WbPageTargetReader/WbPageTargetReader.js";
+import { WbPageAccess } from "./WbPageAccess/WbPageAccess.js";
+import { WbPageFolderExistsService } from "./WbPageFolderExistsService/WbPageFolderExistsService.js";
+import { WbPageDeniedFolders } from "./WbPageDeniedFolders/WbPageDeniedFolders.js";
+import { WbPageReviewReadFilter } from "./WbPageReviewReadFilter/WbPageReviewReadFilter.js";
+import { WbPageReviewTargetLoader } from "./WbPageReviewTargetLoader.js";
+import { WbPageReviewTargetSync } from "./WbPageReviewTargetSync.js";
+import { WbPageReviewTargetReadAccess } from "./WbPageReviewTargetReadAccess.js";
+import { WbPageReviewTargetFolderChain } from "./WbPageReviewTargetFolderChain.js";
+import { WbPageReviewTargetEditor } from "./WbPageReviewTargetEditor.js";
+import { WbPageReviewTargetLink } from "./WbPageReviewTargetLink.js";
+import { WbWorkflowModelParser } from "./WbWorkflowModelParser.js";
+const WbTargetFeature = createFeature({
+    name: "WebsiteBuilderWorkflows/Target",
+    register (container) {
+        container.register(WbPageReviewNamespace);
+        container.register(WbPageTargetReader);
+        container.register(WbPageAccess);
+        container.register(WbPageFolderExistsService);
+        container.register(WbPageDeniedFolders).inContainerScope();
+        container.register(WbPageReviewReadFilter);
+        container.register(WbPageReviewTargetLoader);
+        container.register(WbPageReviewTargetSync);
+        container.register(WbPageReviewTargetReadAccess);
+        container.register(WbPageReviewTargetFolderChain);
+        container.register(WbWorkflowModelParser);
+        container.register(WbPageReviewTargetEditor);
+        container.register(WbPageReviewTargetLink);
+    }
+});
+export { WbTargetFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/target/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/feature.js","sources":["../../../src/features/target/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { WbPageReviewNamespace } from \"./WbPageReviewNamespace.js\";\nimport { WbPageTargetReader } from \"./WbPageTargetReader/WbPageTargetReader.js\";\nimport { WbPageAccess } from \"./WbPageAccess/WbPageAccess.js\";\nimport { WbPageFolderExistsService } from \"./WbPageFolderExistsService/WbPageFolderExistsService.js\";\nimport { WbPageDeniedFolders } from \"./WbPageDeniedFolders/WbPageDeniedFolders.js\";\nimport { WbPageReviewReadFilter } from \"./WbPageReviewReadFilter/WbPageReviewReadFilter.js\";\nimport { WbPageReviewTargetLoader } from \"./WbPageReviewTargetLoader.js\";\nimport { WbPageReviewTargetSync } from \"./WbPageReviewTargetSync.js\";\nimport { WbPageReviewTargetReadAccess } from \"./WbPageReviewTargetReadAccess.js\";\nimport { WbPageReviewTargetFolderChain } from \"./WbPageReviewTargetFolderChain.js\";\nimport { WbPageReviewTargetEditor } from \"./WbPageReviewTargetEditor.js\";\nimport { WbPageReviewTargetLink } from \"./WbPageReviewTargetLink.js\";\nimport { WbWorkflowModelParser } from \"./WbWorkflowModelParser.js\";\n\n/** The `wb.page` target adapter (spec 9.3). */\nexport const WbTargetFeature = createFeature({\n    name: \"WebsiteBuilderWorkflows/Target\",\n    register(container) {\n        // Lets the single CMS handlers cover pages (R51).\n        container.register(WbPageReviewNamespace);\n        container.register(WbPageTargetReader);\n        container.register(WbPageAccess);\n        // The workflow editor's dangling-folder check (D69, R125).\n        container.register(WbPageFolderExistsService);\n        // Caches folder read rules for one request.\n        container.register(WbPageDeniedFolders).inContainerScope();\n        // The page review lists' read filter (Q77).\n        container.register(WbPageReviewReadFilter);\n\n        // Engine ports, one per namespace (R28, R50, R114).\n        container.register(WbPageReviewTargetLoader);\n        container.register(WbPageReviewTargetSync);\n        container.register(WbPageReviewTargetReadAccess);\n        container.register(WbPageReviewTargetFolderChain);\n        // The app and model id of a workflow model, for validation and routing (D137, R113).\n        container.register(WbWorkflowModelParser);\n\n        // The AI step's editor port for pages (R172).\n        container.register(WbPageReviewTargetEditor);\n\n        // Where the notification e-mail links to the page (R195).\n        container.register(WbPageReviewTargetLink);\n    }\n});\n"],"names":["WbTargetFeature","createFeature","container","WbPageReviewNamespace","WbPageTargetReader","WbPageAccess","WbPageFolderExistsService","WbPageDeniedFolders","WbPageReviewReadFilter","WbPageReviewTargetLoader","WbPageReviewTargetSync","WbPageReviewTargetReadAccess","WbPageReviewTargetFolderChain","WbWorkflowModelParser","WbPageReviewTargetEditor","WbPageReviewTargetLink"],"mappings":";;;;;;;;;;;;;;AAgBO,MAAMA,kBAAkBC,cAAc;IACzC,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QAEnBH,UAAU,QAAQ,CAACI;QAEnBJ,UAAU,QAAQ,CAACK,qBAAqB,gBAAgB;QAExDL,UAAU,QAAQ,CAACM;QAGnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,QAAQ,CAACS;QACnBT,UAAU,QAAQ,CAACU;QAEnBV,UAAU,QAAQ,CAACW;QAGnBX,UAAU,QAAQ,CAACY;QAGnBZ,UAAU,QAAQ,CAACa;IACvB;AACJ"}

package/features/target/isWbPageEditorValue.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether `value` is acceptable for the writable page path (R172). The page model stores
+ * `properties` as JSON and nothing type-checks it, so the editor does before writing. The title is
+ * required and never cleared; the SEO text fields accept `null` (the key is removed); the canonical
+ * URL must also be a pathname (`/path`, the admin rule); the SEO flags are booleans. Any other path is not writable. Pure.
+ */
+export declare const isWbPageEditorValue: (path: string, value: unknown) => boolean;
+/** What the model should send for a writable page path, for the error text. Pure. */
+export declare const describeWbPageEditorValue: (path: string) => string;

package/features/target/isWbPageEditorValue.js

@@ -0,0 +1,34 @@
+const PATHNAME_REGEX = new RegExp("^\\/(?:[a-zA-Z0-9._~:@!$&'()*+,;=%/-])*(?:\\?[a-zA-Z0-9._~:@!$&'()*+,;=?/%#[\\]-]*)?(?:#[a-zA-Z0-9._~:@!$&'()*+,;=?/%#[\\]-]*)?$");
+const isPathname = (value)=>"string" == typeof value && !value.startsWith("//") && PATHNAME_REGEX.test(value);
+const isWbPageEditorValue = (path, value)=>{
+    switch(path){
+        case "properties.title":
+            return "string" == typeof value && "" !== value.trim();
+        case "properties.seo.title":
+        case "properties.seo.description":
+            return null === value || "string" == typeof value;
+        case "properties.seo.canonicalUrl":
+            return null === value || isPathname(value);
+        case "properties.seo.noIndex":
+        case "properties.seo.noFollow":
+            return "boolean" == typeof value;
+        default:
+            return false;
+    }
+};
+const describeWbPageEditorValue = (path)=>{
+    switch(path){
+        case "properties.title":
+            return "a non-empty string";
+        case "properties.seo.canonicalUrl":
+            return "a pathname such as /path, or null";
+        case "properties.seo.noIndex":
+        case "properties.seo.noFollow":
+            return "true or false";
+        default:
+            return "a string or null";
+    }
+};
+export { describeWbPageEditorValue, isWbPageEditorValue };
+
+//# sourceMappingURL=isWbPageEditorValue.js.map

package/features/target/isWbPageEditorValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/isWbPageEditorValue.js","sources":["../../../src/features/target/isWbPageEditorValue.ts"],"sourcesContent":["/**\n * The pathname rule of the admin SEO group (`PATHNAME_REGEX` in\n * `packages/app-website-builder/src/presentation/pages/PageEditor/PageSettings/groups/SeoSettingsGroup.ts`),\n * copied here, not imported (the API must not depend on admin code). An empty string passes the\n * admin form (it is optional) but is rejected here: the model must send `null` to clear the key.\n */\nconst PATHNAME_REGEX = new RegExp(\n    `^\\\\/(?:[a-zA-Z0-9._~:@!$&'()*+,;=%/-])*(?:\\\\?[a-zA-Z0-9._~:@!$&'()*+,;=?/%#[\\\\]-]*)?(?:#[a-zA-Z0-9._~:@!$&'()*+,;=?/%#[\\\\]-]*)?$`\n);\n\n/**\n * The admin rule lets `//host` through (its path class includes `/`), and a protocol-relative URL\n * is an external URL, so it is rejected on top of the copied rule.\n */\nconst isPathname = (value: unknown): boolean => {\n    return typeof value === \"string\" && !value.startsWith(\"//\") && PATHNAME_REGEX.test(value);\n};\n\n/**\n * Whether `value` is acceptable for the writable page path (R172). The page model stores\n * `properties` as JSON and nothing type-checks it, so the editor does before writing. The title is\n * required and never cleared; the SEO text fields accept `null` (the key is removed); the canonical\n * URL must also be a pathname (`/path`, the admin rule); the SEO flags are booleans. Any other path is not writable. Pure.\n */\nexport const isWbPageEditorValue = (path: string, value: unknown): boolean => {\n    switch (path) {\n        case \"properties.title\":\n            return typeof value === \"string\" && value.trim() !== \"\";\n        case \"properties.seo.title\":\n        case \"properties.seo.description\":\n            return value === null || typeof value === \"string\";\n        case \"properties.seo.canonicalUrl\":\n            return value === null || isPathname(value);\n        case \"properties.seo.noIndex\":\n        case \"properties.seo.noFollow\":\n            return typeof value === \"boolean\";\n        default:\n            return false;\n    }\n};\n\n/** What the model should send for a writable page path, for the error text. Pure. */\nexport const describeWbPageEditorValue = (path: string): string => {\n    switch (path) {\n        case \"properties.title\":\n            return \"a non-empty string\";\n        case \"properties.seo.canonicalUrl\":\n            return \"a pathname such as /path, or null\";\n        case \"properties.seo.noIndex\":\n        case \"properties.seo.noFollow\":\n            return \"true or false\";\n        default:\n            return \"a string or null\";\n    }\n};\n"],"names":["PATHNAME_REGEX","RegExp","isPathname","value","isWbPageEditorValue","path","describeWbPageEditorValue"],"mappings":"AAMA,MAAMA,iBAAiB,IAAIC,OACvB;AAOJ,MAAMC,aAAa,CAACC,QACT,AAAiB,YAAjB,OAAOA,SAAsB,CAACA,MAAM,UAAU,CAAC,SAASH,eAAe,IAAI,CAACG;AAShF,MAAMC,sBAAsB,CAACC,MAAcF;IAC9C,OAAQE;QACJ,KAAK;YACD,OAAO,AAAiB,YAAjB,OAAOF,SAAsBA,AAAiB,OAAjBA,MAAM,IAAI;QAClD,KAAK;QACL,KAAK;YACD,OAAOA,AAAU,SAAVA,SAAkB,AAAiB,YAAjB,OAAOA;QACpC,KAAK;YACD,OAAOA,AAAU,SAAVA,SAAkBD,WAAWC;QACxC,KAAK;QACL,KAAK;YACD,OAAO,AAAiB,aAAjB,OAAOA;QAClB;YACI,OAAO;IACf;AACJ;AAGO,MAAMG,4BAA4B,CAACD;IACtC,OAAQA;QACJ,KAAK;YACD,OAAO;QACX,KAAK;YACD,OAAO;QACX,KAAK;QACL,KAAK;YACD,OAAO;QACX;YACI,OAAO;IACf;AACJ"}

package/features/target/toWbPageEditorFields.d.ts

@@ -0,0 +1,32 @@
+import type { WbPage } from "@webiny/api-website-builder/domain/page/abstractions.js";
+import type { ReviewTargetEditorField } from "@webiny/api-workflows/features/review/ReviewTargetEditor/abstractions.js";
+/** The parts of a page the editor reads. */
+export type WbPageEditorSource = Pick<WbPage, "properties" | "location" | "status" | "metadata" | "bindings" | "elements" | "extensions">;
+/** A field the AI may write (R172). */
+export interface WbPageWritableField {
+    /** The key `update` takes. */
+    path: string;
+    /** The key inside `properties.seo`; empty for the page title. */
+    key: string;
+    label: string;
+    type: string;
+}
+/** What the model reads for the element tree instead of the tree itself. */
+export interface WbElementsSummary {
+    count: number;
+    /** Component name to the number of elements that use it. */
+    components: Record<string, number>;
+}
+export declare const WB_PAGE_TITLE_FIELD: WbPageWritableField;
+/** The SEO scalars of the page editor's SEO group (R172). `metaTags` and the rest are read-only. */
+export declare const WB_PAGE_SEO_FIELDS: WbPageWritableField[];
+/**
+ * The page as the target editor shows it (R172): the title, every other `properties` key as one
+ * read-only row with its whole value, the five writable SEO scalars, the rest of the SEO group as
+ * read-only rows, the read-only page parts (`location`, `status`, `metadata`, `bindings`,
+ * `extensions`) and a read-only summary of the element tree. `properties.path` and
+ * `properties.language` are never writable. A `properties` key that contains a dot is skipped: its
+ * row path could shadow an allowlisted path. Throws when `properties` is missing (the editor turns
+ * that into a failed Result). Pure.
+ */
+export declare const toWbPageEditorFields: (page: WbPageEditorSource) => ReviewTargetEditorField[];