@webiny/api-headless-cms-workflows 0.0.0-unstable.0156a4c312

package/features/target/feature.js

@@ -0,0 +1,41 @@
+import { createFeature } from "@webiny/feature/api";
+import { CmsModelReviewNamespace } from "./CmsEntryReviewNamespace/CmsModelReviewNamespace.js";
+import { CmsModelGroupService } from "./CmsModelGroupService/CmsModelGroupService.js";
+import { CmsEntryTargetReader } from "./CmsEntryTargetReader/CmsEntryTargetReader.js";
+import { CmsEntryAccess } from "./CmsEntryAccess/CmsEntryAccess.js";
+import { CmsEntryFolderExistsService } from "./CmsEntryFolderExistsService/CmsEntryFolderExistsService.js";
+import { CmsEntryDeniedFolders } from "./CmsEntryDeniedFolders/CmsEntryDeniedFolders.js";
+import { CmsEntryReviewReadFilter } from "./CmsEntryReviewReadFilter/CmsEntryReviewReadFilter.js";
+import { CandidateFolderReadRules } from "./CandidateFolderReadRules/CandidateFolderReadRules.js";
+import { CmsEntryReviewTargetLoader } from "./CmsEntryReviewTargetLoader.js";
+import { CmsEntryReviewTargetSync } from "./CmsEntryReviewTargetSync.js";
+import { CmsEntryReviewTargetReadAccess } from "./CmsEntryReviewTargetReadAccess.js";
+import { CmsEntryReviewTargetFolderChain } from "./CmsEntryReviewTargetFolderChain.js";
+import { CmsEntryReviewTargetEditor } from "./CmsEntryReviewTargetEditor.js";
+import { CmsEntryReviewTargetLink } from "./CmsEntryReviewTargetLink.js";
+import { WorkflowEntrySystemField } from "./WorkflowEntrySystemField.js";
+import { CmsWorkflowModelParser } from "./CmsWorkflowModelParser.js";
+const CmsTargetFeature = createFeature({
+    name: "CmsWorkflows/Target",
+    register (container) {
+        container.register(CmsModelReviewNamespace);
+        container.register(CmsModelGroupService);
+        container.register(CmsEntryTargetReader);
+        container.register(CmsEntryAccess);
+        container.register(CmsEntryFolderExistsService);
+        container.register(CmsEntryDeniedFolders).inContainerScope();
+        container.register(CmsEntryReviewReadFilter);
+        container.register(CandidateFolderReadRules);
+        container.register(CmsEntryReviewTargetLoader);
+        container.register(CmsEntryReviewTargetSync);
+        container.register(CmsEntryReviewTargetReadAccess);
+        container.register(CmsEntryReviewTargetFolderChain);
+        container.register(CmsWorkflowModelParser);
+        container.register(CmsEntryReviewTargetEditor);
+        container.register(CmsEntryReviewTargetLink);
+        container.register(WorkflowEntrySystemField);
+    }
+});
+export { CmsTargetFeature };
+
+//# 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 { CmsModelReviewNamespace } from \"./CmsEntryReviewNamespace/CmsModelReviewNamespace.js\";\nimport { CmsModelGroupService } from \"./CmsModelGroupService/CmsModelGroupService.js\";\nimport { CmsEntryTargetReader } from \"./CmsEntryTargetReader/CmsEntryTargetReader.js\";\nimport { CmsEntryAccess } from \"./CmsEntryAccess/CmsEntryAccess.js\";\nimport { CmsEntryFolderExistsService } from \"./CmsEntryFolderExistsService/CmsEntryFolderExistsService.js\";\nimport { CmsEntryDeniedFolders } from \"./CmsEntryDeniedFolders/CmsEntryDeniedFolders.js\";\nimport { CmsEntryReviewReadFilter } from \"./CmsEntryReviewReadFilter/CmsEntryReviewReadFilter.js\";\nimport { CandidateFolderReadRules } from \"./CandidateFolderReadRules/CandidateFolderReadRules.js\";\nimport { CmsEntryReviewTargetLoader } from \"./CmsEntryReviewTargetLoader.js\";\nimport { CmsEntryReviewTargetSync } from \"./CmsEntryReviewTargetSync.js\";\nimport { CmsEntryReviewTargetReadAccess } from \"./CmsEntryReviewTargetReadAccess.js\";\nimport { CmsEntryReviewTargetFolderChain } from \"./CmsEntryReviewTargetFolderChain.js\";\nimport { CmsEntryReviewTargetEditor } from \"./CmsEntryReviewTargetEditor.js\";\nimport { CmsEntryReviewTargetLink } from \"./CmsEntryReviewTargetLink.js\";\nimport { WorkflowEntrySystemField } from \"./WorkflowEntrySystemField.js\";\nimport { CmsWorkflowModelParser } from \"./CmsWorkflowModelParser.js\";\n\n/** The `cms.*` target adapter (spec 9.3). */\nexport const CmsTargetFeature = createFeature({\n    name: \"CmsWorkflows/Target\",\n    register(container) {\n        container.register(CmsModelReviewNamespace);\n        container.register(CmsModelGroupService);\n        container.register(CmsEntryTargetReader);\n        container.register(CmsEntryAccess);\n        container.register(CmsEntryFolderExistsService);\n        // Caches folder read rules for one request.\n        container.register(CmsEntryDeniedFolders).inContainerScope();\n        container.register(CmsEntryReviewReadFilter);\n        // Folder rules for routing candidates, shared with the Website Builder adapter.\n        container.register(CandidateFolderReadRules);\n\n        // Engine ports, one per namespace (R28, R50, R114).\n        container.register(CmsEntryReviewTargetLoader);\n        container.register(CmsEntryReviewTargetSync);\n        container.register(CmsEntryReviewTargetReadAccess);\n        container.register(CmsEntryReviewTargetFolderChain);\n        // The app and model id of a workflow model, for validation and routing (D137, R113).\n        container.register(CmsWorkflowModelParser);\n\n        // The AI step's editor port, one per namespace (R172).\n        container.register(CmsEntryReviewTargetEditor);\n\n        // Where the notification e-mail links to the content, one per namespace (R195).\n        container.register(CmsEntryReviewTargetLink);\n\n        // `system.workflow` as a filterable entry system field (spec 4.5).\n        container.register(WorkflowEntrySystemField);\n    }\n});\n"],"names":["CmsTargetFeature","createFeature","container","CmsModelReviewNamespace","CmsModelGroupService","CmsEntryTargetReader","CmsEntryAccess","CmsEntryFolderExistsService","CmsEntryDeniedFolders","CmsEntryReviewReadFilter","CandidateFolderReadRules","CmsEntryReviewTargetLoader","CmsEntryReviewTargetSync","CmsEntryReviewTargetReadAccess","CmsEntryReviewTargetFolderChain","CmsWorkflowModelParser","CmsEntryReviewTargetEditor","CmsEntryReviewTargetLink","WorkflowEntrySystemField"],"mappings":";;;;;;;;;;;;;;;;;AAmBO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QAEnBL,UAAU,QAAQ,CAACM,uBAAuB,gBAAgB;QAC1DN,UAAU,QAAQ,CAACO;QAEnBP,UAAU,QAAQ,CAACQ;QAGnBR,UAAU,QAAQ,CAACS;QACnBT,UAAU,QAAQ,CAACU;QACnBV,UAAU,QAAQ,CAACW;QACnBX,UAAU,QAAQ,CAACY;QAEnBZ,UAAU,QAAQ,CAACa;QAGnBb,UAAU,QAAQ,CAACc;QAGnBd,UAAU,QAAQ,CAACe;QAGnBf,UAAU,QAAQ,CAACgB;IACvB;AACJ"}

package/features/target/getModelSafeValidationMessage.d.ts

@@ -0,0 +1,11 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+/** What the model reads when a field failed validation with a message it must not see. */
+export declare const GENERIC_VALIDATION_MESSAGE = "The value could not be validated.";
+/**
+ * The CMS validation turns a validator that THREW into its raw `ex.message`, and a validator
+ * nobody registered into `There are no "<name>" validators defined.` Neither may reach the model
+ * (R87). A message is safe to show when it is one the model author configured on that field
+ * (`validation[].message`, `listValidation[].message`) or one of the CMS's own fixed datetime and
+ * predefined-value texts. Returns the message when safe, otherwise `null`. Pure.
+ */
+export declare const getModelSafeValidationMessage: (model: Pick<CmsModel, "fields">, path: string[], error: unknown) => string | null;

package/features/target/getModelSafeValidationMessage.js

@@ -0,0 +1,28 @@
+const GENERIC_VALIDATION_MESSAGE = "The value could not be validated.";
+const PREDEFINED_VALUE_MESSAGE = "Value sent does not match any of the available predefined values.";
+const DATETIME_FORMAT_MESSAGE = /^Invalid (date|time|dateTime) format for field "[^"]*"\. Expected [^"]*\.$/;
+const findField = (fields, path)=>{
+    let current = fields;
+    let found = null;
+    for (const segment of path){
+        found = current.find((item)=>item.fieldId === segment) ?? null;
+        if (!found) return null;
+        const children = found.settings?.fields;
+        current = Array.isArray(children) ? children : [];
+    }
+    return found;
+};
+const getModelSafeValidationMessage = (model, path, error)=>{
+    if ("string" != typeof error) return null;
+    if (error === PREDEFINED_VALUE_MESSAGE || DATETIME_FORMAT_MESSAGE.test(error)) return error;
+    const field = findField(model.fields, path);
+    if (!field) return null;
+    const configured = [
+        ...field.validation ?? [],
+        ...field.listValidation ?? []
+    ].map((item)=>item.message);
+    return configured.includes(error) ? error : null;
+};
+export { GENERIC_VALIDATION_MESSAGE, getModelSafeValidationMessage };
+
+//# sourceMappingURL=getModelSafeValidationMessage.js.map

package/features/target/getModelSafeValidationMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/getModelSafeValidationMessage.js","sources":["../../../src/features/target/getModelSafeValidationMessage.ts"],"sourcesContent":["import type { CmsModel, CmsModelField } from \"@webiny/api-headless-cms/types/index.js\";\n\n/** What the model reads when a field failed validation with a message it must not see. */\nexport const GENERIC_VALIDATION_MESSAGE = \"The value could not be validated.\";\n\nconst PREDEFINED_VALUE_MESSAGE =\n    \"Value sent does not match any of the available predefined values.\";\nconst DATETIME_FORMAT_MESSAGE =\n    /^Invalid (date|time|dateTime) format for field \"[^\"]*\"\\. Expected [^\"]*\\.$/;\n\nconst findField = (fields: CmsModelField[], path: string[]): CmsModelField | null => {\n    let current: CmsModelField[] = fields;\n    let found: CmsModelField | null = null;\n    for (const segment of path) {\n        found = current.find(item => item.fieldId === segment) ?? null;\n        if (!found) {\n            return null;\n        }\n        const children = found.settings?.fields;\n        current = Array.isArray(children) ? children : [];\n    }\n    return found;\n};\n\n/**\n * The CMS validation turns a validator that THREW into its raw `ex.message`, and a validator\n * nobody registered into `There are no \"<name>\" validators defined.` Neither may reach the model\n * (R87). A message is safe to show when it is one the model author configured on that field\n * (`validation[].message`, `listValidation[].message`) or one of the CMS's own fixed datetime and\n * predefined-value texts. Returns the message when safe, otherwise `null`. Pure.\n */\nexport const getModelSafeValidationMessage = (\n    model: Pick<CmsModel, \"fields\">,\n    path: string[],\n    error: unknown\n): string | null => {\n    if (typeof error !== \"string\") {\n        return null;\n    }\n    if (error === PREDEFINED_VALUE_MESSAGE || DATETIME_FORMAT_MESSAGE.test(error)) {\n        return error;\n    }\n    const field = findField(model.fields, path);\n    if (!field) {\n        return null;\n    }\n    const configured = [...(field.validation ?? []), ...(field.listValidation ?? [])].map(\n        item => item.message\n    );\n    return configured.includes(error) ? error : null;\n};\n"],"names":["GENERIC_VALIDATION_MESSAGE","PREDEFINED_VALUE_MESSAGE","DATETIME_FORMAT_MESSAGE","findField","fields","path","current","found","segment","item","children","Array","getModelSafeValidationMessage","model","error","field","configured"],"mappings":"AAGO,MAAMA,6BAA6B;AAE1C,MAAMC,2BACF;AACJ,MAAMC,0BACF;AAEJ,MAAMC,YAAY,CAACC,QAAyBC;IACxC,IAAIC,UAA2BF;IAC/B,IAAIG,QAA8B;IAClC,KAAK,MAAMC,WAAWH,KAAM;QACxBE,QAAQD,QAAQ,IAAI,CAACG,CAAAA,OAAQA,KAAK,OAAO,KAAKD,YAAY;QAC1D,IAAI,CAACD,OACD,OAAO;QAEX,MAAMG,WAAWH,MAAM,QAAQ,EAAE;QACjCD,UAAUK,MAAM,OAAO,CAACD,YAAYA,WAAW,EAAE;IACrD;IACA,OAAOH;AACX;AASO,MAAMK,gCAAgC,CACzCC,OACAR,MACAS;IAEA,IAAI,AAAiB,YAAjB,OAAOA,OACP,OAAO;IAEX,IAAIA,UAAUb,4BAA4BC,wBAAwB,IAAI,CAACY,QACnE,OAAOA;IAEX,MAAMC,QAAQZ,UAAUU,MAAM,MAAM,EAAER;IACtC,IAAI,CAACU,OACD,OAAO;IAEX,MAAMC,aAAa;WAAKD,MAAM,UAAU,IAAI,EAAE;WAAOA,MAAM,cAAc,IAAI,EAAE;KAAE,CAAC,GAAG,CACjFN,CAAAA,OAAQA,KAAK,OAAO;IAExB,OAAOO,WAAW,QAAQ,CAACF,SAASA,QAAQ;AAChD"}

package/features/target/isEditorFieldValue.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether `value` has the JavaScript type the CMS field type stores. The CMS update path validates
+ * validators, required and datetime formats but does not type-check (the GraphQL schema does that
+ * for API writes), so the editor does it before writing (R172). `null` clears a field and is
+ * always accepted, so the model's own `required` validator decides. Pure.
+ */
+export declare const isEditorFieldValue: (type: string, value: unknown) => boolean;
+/** What the model should send for a writable field type, for the error text. Pure. */
+export declare const describeEditorFieldValue: (type: string) => string;

package/features/target/isEditorFieldValue.js

@@ -0,0 +1,30 @@
+const isEditorFieldValue = (type, value)=>{
+    if (null === value) return true;
+    switch(type){
+        case "text":
+        case "long-text":
+        case "datetime":
+            return "string" == typeof value;
+        case "number":
+            return "number" == typeof value && Number.isFinite(value);
+        case "boolean":
+            return "boolean" == typeof value;
+        default:
+            return false;
+    }
+};
+const describeEditorFieldValue = (type)=>{
+    switch(type){
+        case "number":
+            return "a number";
+        case "boolean":
+            return "true or false";
+        case "datetime":
+            return "a date or time string";
+        default:
+            return "a string";
+    }
+};
+export { describeEditorFieldValue, isEditorFieldValue };
+
+//# sourceMappingURL=isEditorFieldValue.js.map

package/features/target/isEditorFieldValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/isEditorFieldValue.js","sources":["../../../src/features/target/isEditorFieldValue.ts"],"sourcesContent":["/**\n * Whether `value` has the JavaScript type the CMS field type stores. The CMS update path validates\n * validators, required and datetime formats but does not type-check (the GraphQL schema does that\n * for API writes), so the editor does it before writing (R172). `null` clears a field and is\n * always accepted, so the model's own `required` validator decides. Pure.\n */\nexport const isEditorFieldValue = (type: string, value: unknown): boolean => {\n    if (value === null) {\n        return true;\n    }\n    switch (type) {\n        case \"text\":\n        case \"long-text\":\n        case \"datetime\":\n            return typeof value === \"string\";\n        case \"number\":\n            return typeof value === \"number\" && Number.isFinite(value);\n        case \"boolean\":\n            return typeof value === \"boolean\";\n        default:\n            return false;\n    }\n};\n\n/** What the model should send for a writable field type, for the error text. Pure. */\nexport const describeEditorFieldValue = (type: string): string => {\n    switch (type) {\n        case \"number\":\n            return \"a number\";\n        case \"boolean\":\n            return \"true or false\";\n        case \"datetime\":\n            return \"a date or time string\";\n        default:\n            return \"a string\";\n    }\n};\n"],"names":["isEditorFieldValue","type","value","Number","describeEditorFieldValue"],"mappings":"AAMO,MAAMA,qBAAqB,CAACC,MAAcC;IAC7C,IAAIA,AAAU,SAAVA,OACA,OAAO;IAEX,OAAQD;QACJ,KAAK;QACL,KAAK;QACL,KAAK;YACD,OAAO,AAAiB,YAAjB,OAAOC;QAClB,KAAK;YACD,OAAO,AAAiB,YAAjB,OAAOA,SAAsBC,OAAO,QAAQ,CAACD;QACxD,KAAK;YACD,OAAO,AAAiB,aAAjB,OAAOA;QAClB;YACI,OAAO;IACf;AACJ;AAGO,MAAME,2BAA2B,CAACH;IACrC,OAAQA;QACJ,KAAK;YACD,OAAO;QACX,KAAK;YACD,OAAO;QACX,KAAK;YACD,OAAO;QACX;YACI,OAAO;IACf;AACJ"}

package/features/target/toCmsReviewTarget.d.ts

@@ -0,0 +1,4 @@
+import type { ReviewTarget } from "@webiny/api-workflows/features/review/ReviewTargetLoader/index.js";
+import type { CmsEntryTargetReader } from "./CmsEntryTargetReader/index.js";
+/** Title and typed `TargetContext` of a CMS revision (spec 9.3, R66). Pure. */
+export declare const toCmsReviewTarget: (target: CmsEntryTargetReader.Target) => ReviewTarget;

package/features/target/toCmsReviewTarget.js

@@ -0,0 +1,26 @@
+import { getEntryTitle } from "@webiny/api-headless-cms/utils/getEntryTitle.js";
+import { ROOT_FOLDER } from "@webiny/api-headless-cms/constants.js";
+import { toCmsFolderType } from "../../utils/folderType.js";
+const toCmsReviewTarget = (target)=>{
+    const { model, entry } = target;
+    const title = getEntryTitle(model, entry);
+    const folderId = entry.location?.folderId;
+    return {
+        title,
+        context: {
+            folder: folderId && folderId !== ROOT_FOLDER ? {
+                id: folderId,
+                type: toCmsFolderType(model.modelId)
+            } : null,
+            modelId: model.modelId,
+            title,
+            author: {
+                id: entry.createdBy.id,
+                displayName: entry.createdBy.displayName
+            }
+        }
+    };
+};
+export { toCmsReviewTarget };
+
+//# sourceMappingURL=toCmsReviewTarget.js.map

package/features/target/toCmsReviewTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/toCmsReviewTarget.js","sources":["../../../src/features/target/toCmsReviewTarget.ts"],"sourcesContent":["import { getEntryTitle } from \"@webiny/api-headless-cms/utils/getEntryTitle.js\";\nimport { ROOT_FOLDER } from \"@webiny/api-headless-cms/constants.js\";\nimport type { ReviewTarget } from \"@webiny/api-workflows/features/review/ReviewTargetLoader/index.js\";\nimport { toCmsFolderType } from \"~/utils/folderType.js\";\nimport type { CmsEntryTargetReader } from \"./CmsEntryTargetReader/index.js\";\n\n/** Title and typed `TargetContext` of a CMS revision (spec 9.3, R66). Pure. */\nexport const toCmsReviewTarget = (target: CmsEntryTargetReader.Target): ReviewTarget => {\n    const { model, entry } = target;\n    const title = getEntryTitle(model, entry);\n    const folderId = entry.location?.folderId;\n    return {\n        title,\n        context: {\n            folder:\n                folderId && folderId !== ROOT_FOLDER\n                    ? { id: folderId, type: toCmsFolderType(model.modelId) }\n                    : null,\n            modelId: model.modelId,\n            title,\n            author: { id: entry.createdBy.id, displayName: entry.createdBy.displayName }\n        }\n    };\n};\n"],"names":["toCmsReviewTarget","target","model","entry","title","getEntryTitle","folderId","ROOT_FOLDER","toCmsFolderType"],"mappings":";;;AAOO,MAAMA,oBAAoB,CAACC;IAC9B,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF;IACzB,MAAMG,QAAQC,cAAcH,OAAOC;IACnC,MAAMG,WAAWH,MAAM,QAAQ,EAAE;IACjC,OAAO;QACHC;QACA,SAAS;YACL,QACIE,YAAYA,aAAaC,cACnB;gBAAE,IAAID;gBAAU,MAAME,gBAAgBN,MAAM,OAAO;YAAE,IACrD;YACV,SAASA,MAAM,OAAO;YACtBE;YACA,QAAQ;gBAAE,IAAID,MAAM,SAAS,CAAC,EAAE;gBAAE,aAAaA,MAAM,SAAS,CAAC,WAAW;YAAC;QAC/E;IACJ;AACJ"}

package/features/target/toEditorFields.d.ts

@@ -0,0 +1,9 @@
+import type { CmsEntryValues, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { ReviewTargetEditorField } from "@webiny/api-workflows/features/review/ReviewTargetEditor/abstractions.js";
+/**
+ * The fields of a CMS revision as the target editor shows them (R172): every field, nested
+ * `object` fields flattened to dotted paths, `writable` only for top-level or nested-object fields
+ * of a writable type that are not `multipleValues` (`field.list`). A list object is one read-only
+ * row and is never descended into, so nothing inside a `multipleValues` object is writable. Pure.
+ */
+export declare const toEditorFields: (model: Pick<CmsModel, "fields">, values: CmsEntryValues) => ReviewTargetEditorField[];

package/features/target/toEditorFields.js

@@ -0,0 +1,48 @@
+const WRITABLE_FIELD_TYPES = [
+    "text",
+    "long-text",
+    "number",
+    "boolean",
+    "datetime"
+];
+const isRecord = (value)=>"object" == typeof value && null !== value && !Array.isArray(value);
+const toDatetimeString = (value, subtype)=>{
+    if (!(value instanceof Date)) return value;
+    if (Number.isNaN(value.getTime())) return null;
+    const iso = value.toISOString();
+    return "date" === subtype ? iso.slice(0, 10) : iso;
+};
+const normalizeValue = (field, value)=>{
+    if (void 0 === value) return null;
+    if ("datetime" !== field.type) return value;
+    const subtype = field.settings?.type;
+    if (field.list && Array.isArray(value)) return value.map((item)=>toDatetimeString(item, subtype));
+    return toDatetimeString(value, subtype);
+};
+const flattenFields = (fields, values, parentPath)=>{
+    const rows = [];
+    for (const field of fields){
+        const segments = [
+            ...parentPath,
+            field.fieldId
+        ];
+        const value = values[field.fieldId];
+        const children = field.settings?.fields;
+        if ("object" === field.type && !field.list && Array.isArray(children)) {
+            rows.push(...flattenFields(children, isRecord(value) ? value : {}, segments));
+            continue;
+        }
+        rows.push({
+            path: segments.join("."),
+            label: field.label,
+            type: field.type,
+            value: normalizeValue(field, value),
+            writable: !field.list && WRITABLE_FIELD_TYPES.includes(field.type)
+        });
+    }
+    return rows;
+};
+const toEditorFields = (model, values)=>flattenFields(model.fields, values, []);
+export { toEditorFields };
+
+//# sourceMappingURL=toEditorFields.js.map

package/features/target/toEditorFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/toEditorFields.js","sources":["../../../src/features/target/toEditorFields.ts"],"sourcesContent":["import type {\n    CmsEntryValues,\n    CmsModel,\n    CmsModelField\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport type { ReviewTargetEditorField } from \"@webiny/api-workflows/features/review/ReviewTargetEditor/abstractions.js\";\n\n/** The field types the AI may write (R172). Everything else is read-only. */\nconst WRITABLE_FIELD_TYPES: string[] = [\"text\", \"long-text\", \"number\", \"boolean\", \"datetime\"];\n\nconst isRecord = (value: unknown): value is Record<string, unknown> => {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n};\n\n/**\n * A datetime value as the CMS write validator accepts it. The CMS reads a datetime as a `Date`; the\n * AI gets a string: `YYYY-MM-DD` for `date`, an ISO string otherwise. Strings pass unchanged and an\n * invalid `Date` is `null`.\n */\nconst toDatetimeString = (value: unknown, subtype: unknown): unknown => {\n    if (!(value instanceof Date)) {\n        return value;\n    }\n    if (Number.isNaN(value.getTime())) {\n        return null;\n    }\n    const iso = value.toISOString();\n    return subtype === \"date\" ? iso.slice(0, 10) : iso;\n};\n\nconst normalizeValue = (field: CmsModelField, value: unknown): unknown => {\n    if (value === undefined) {\n        return null;\n    }\n    if (field.type !== \"datetime\") {\n        return value;\n    }\n    const subtype = field.settings?.type;\n    if (field.list && Array.isArray(value)) {\n        return value.map(item => toDatetimeString(item, subtype));\n    }\n    return toDatetimeString(value, subtype);\n};\n\nconst flattenFields = (\n    fields: CmsModelField[],\n    values: Record<string, unknown>,\n    parentPath: string[]\n): ReviewTargetEditorField[] => {\n    const rows: ReviewTargetEditorField[] = [];\n    for (const field of fields) {\n        const segments = [...parentPath, field.fieldId];\n        const value = values[field.fieldId];\n        const children = field.settings?.fields;\n        if (field.type === \"object\" && !field.list && Array.isArray(children)) {\n            rows.push(...flattenFields(children, isRecord(value) ? value : {}, segments));\n            continue;\n        }\n        rows.push({\n            path: segments.join(\".\"),\n            label: field.label,\n            type: field.type,\n            value: normalizeValue(field, value),\n            writable: !field.list && WRITABLE_FIELD_TYPES.includes(field.type)\n        });\n    }\n    return rows;\n};\n\n/**\n * The fields of a CMS revision as the target editor shows them (R172): every field, nested\n * `object` fields flattened to dotted paths, `writable` only for top-level or nested-object fields\n * of a writable type that are not `multipleValues` (`field.list`). A list object is one read-only\n * row and is never descended into, so nothing inside a `multipleValues` object is writable. Pure.\n */\nexport const toEditorFields = (\n    model: Pick<CmsModel, \"fields\">,\n    values: CmsEntryValues\n): ReviewTargetEditorField[] => {\n    return flattenFields(model.fields, values, []);\n};\n"],"names":["WRITABLE_FIELD_TYPES","isRecord","value","Array","toDatetimeString","subtype","Date","Number","iso","normalizeValue","field","undefined","item","flattenFields","fields","values","parentPath","rows","segments","children","toEditorFields","model"],"mappings":"AAQA,MAAMA,uBAAiC;IAAC;IAAQ;IAAa;IAAU;IAAW;CAAW;AAE7F,MAAMC,WAAW,CAACC,QACP,AAAiB,YAAjB,OAAOA,SAAsBA,AAAU,SAAVA,SAAkB,CAACC,MAAM,OAAO,CAACD;AAQzE,MAAME,mBAAmB,CAACF,OAAgBG;IACtC,IAAI,CAAEH,CAAAA,iBAAiBI,IAAG,GACtB,OAAOJ;IAEX,IAAIK,OAAO,KAAK,CAACL,MAAM,OAAO,KAC1B,OAAO;IAEX,MAAMM,MAAMN,MAAM,WAAW;IAC7B,OAAOG,AAAY,WAAZA,UAAqBG,IAAI,KAAK,CAAC,GAAG,MAAMA;AACnD;AAEA,MAAMC,iBAAiB,CAACC,OAAsBR;IAC1C,IAAIA,AAAUS,WAAVT,OACA,OAAO;IAEX,IAAIQ,AAAe,eAAfA,MAAM,IAAI,EACV,OAAOR;IAEX,MAAMG,UAAUK,MAAM,QAAQ,EAAE;IAChC,IAAIA,MAAM,IAAI,IAAIP,MAAM,OAAO,CAACD,QAC5B,OAAOA,MAAM,GAAG,CAACU,CAAAA,OAAQR,iBAAiBQ,MAAMP;IAEpD,OAAOD,iBAAiBF,OAAOG;AACnC;AAEA,MAAMQ,gBAAgB,CAClBC,QACAC,QACAC;IAEA,MAAMC,OAAkC,EAAE;IAC1C,KAAK,MAAMP,SAASI,OAAQ;QACxB,MAAMI,WAAW;eAAIF;YAAYN,MAAM,OAAO;SAAC;QAC/C,MAAMR,QAAQa,MAAM,CAACL,MAAM,OAAO,CAAC;QACnC,MAAMS,WAAWT,MAAM,QAAQ,EAAE;QACjC,IAAIA,AAAe,aAAfA,MAAM,IAAI,IAAiB,CAACA,MAAM,IAAI,IAAIP,MAAM,OAAO,CAACgB,WAAW;YACnEF,KAAK,IAAI,IAAIJ,cAAcM,UAAUlB,SAASC,SAASA,QAAQ,CAAC,GAAGgB;YACnE;QACJ;QACAD,KAAK,IAAI,CAAC;YACN,MAAMC,SAAS,IAAI,CAAC;YACpB,OAAOR,MAAM,KAAK;YAClB,MAAMA,MAAM,IAAI;YAChB,OAAOD,eAAeC,OAAOR;YAC7B,UAAU,CAACQ,MAAM,IAAI,IAAIV,qBAAqB,QAAQ,CAACU,MAAM,IAAI;QACrE;IACJ;IACA,OAAOO;AACX;AAQO,MAAMG,iBAAiB,CAC1BC,OACAN,SAEOF,cAAcQ,MAAM,MAAM,EAAEN,QAAQ,EAAE"}

package/features/target/toEntryValuesPatch.d.ts

@@ -0,0 +1,9 @@
+import type { CmsEntryValues } from "@webiny/api-headless-cms/types/index.js";
+/**
+ * The `values` of the entry update for dotted-path writes. The CMS update merges top-level keys
+ * only, so a nested write has to carry its whole object: every object on the way is a copy of the
+ * current one with the new leaf set (siblings survive), and a `null` or missing object is created.
+ * Only the touched top-level keys are in the patch. The paths are already checked against the
+ * model (`toEditorFields`), so they are field ids. The current values are never mutated. Pure.
+ */
+export declare const toEntryValuesPatch: (current: CmsEntryValues, updates: Record<string, unknown>) => Record<string, unknown>;

package/features/target/toEntryValuesPatch.js

@@ -0,0 +1,31 @@
+const isRecord = (value)=>"object" == typeof value && null !== value && !Array.isArray(value);
+const toEntryValuesPatch = (current, updates)=>{
+    const patch = {};
+    const copies = new Set();
+    for (const [path, value] of Object.entries(updates)){
+        const segments = path.split(".");
+        const leaf = segments[segments.length - 1];
+        let target = patch;
+        let source = current;
+        for (const segment of segments.slice(0, -1)){
+            const existing = target[segment];
+            const original = source[segment];
+            let copy;
+            if (isRecord(existing) && copies.has(existing)) copy = existing;
+            else {
+                copy = isRecord(original) ? {
+                    ...original
+                } : {};
+                copies.add(copy);
+            }
+            target[segment] = copy;
+            target = copy;
+            source = isRecord(original) ? original : {};
+        }
+        target[leaf] = value;
+    }
+    return patch;
+};
+export { toEntryValuesPatch };
+
+//# sourceMappingURL=toEntryValuesPatch.js.map

package/features/target/toEntryValuesPatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/toEntryValuesPatch.js","sources":["../../../src/features/target/toEntryValuesPatch.ts"],"sourcesContent":["import type { CmsEntryValues } from \"@webiny/api-headless-cms/types/index.js\";\n\nconst isRecord = (value: unknown): value is Record<string, unknown> => {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n};\n\n/**\n * The `values` of the entry update for dotted-path writes. The CMS update merges top-level keys\n * only, so a nested write has to carry its whole object: every object on the way is a copy of the\n * current one with the new leaf set (siblings survive), and a `null` or missing object is created.\n * Only the touched top-level keys are in the patch. The paths are already checked against the\n * model (`toEditorFields`), so they are field ids. The current values are never mutated. Pure.\n */\nexport const toEntryValuesPatch = (\n    current: CmsEntryValues,\n    updates: Record<string, unknown>\n): Record<string, unknown> => {\n    const patch: Record<string, unknown> = {};\n    // Objects this call created: only those may be written into. A copy of an object carries the\n    // current nested objects by reference, so those must be copied before they are changed.\n    const copies = new Set<Record<string, unknown>>();\n    for (const [path, value] of Object.entries(updates)) {\n        const segments = path.split(\".\");\n        const leaf = segments[segments.length - 1];\n        let target = patch;\n        let source: Record<string, unknown> = current;\n        for (const segment of segments.slice(0, -1)) {\n            const existing = target[segment];\n            const original = source[segment];\n            let copy: Record<string, unknown>;\n            if (isRecord(existing) && copies.has(existing)) {\n                copy = existing;\n            } else {\n                copy = isRecord(original) ? { ...original } : {};\n                copies.add(copy);\n            }\n            target[segment] = copy;\n            target = copy;\n            source = isRecord(original) ? original : {};\n        }\n        target[leaf] = value;\n    }\n    return patch;\n};\n"],"names":["isRecord","value","Array","toEntryValuesPatch","current","updates","patch","copies","Set","path","Object","segments","leaf","target","source","segment","existing","original","copy"],"mappings":"AAEA,MAAMA,WAAW,CAACC,QACP,AAAiB,YAAjB,OAAOA,SAAsBA,AAAU,SAAVA,SAAkB,CAACC,MAAM,OAAO,CAACD;AAUlE,MAAME,qBAAqB,CAC9BC,SACAC;IAEA,MAAMC,QAAiC,CAAC;IAGxC,MAAMC,SAAS,IAAIC;IACnB,KAAK,MAAM,CAACC,MAAMR,MAAM,IAAIS,OAAO,OAAO,CAACL,SAAU;QACjD,MAAMM,WAAWF,KAAK,KAAK,CAAC;QAC5B,MAAMG,OAAOD,QAAQ,CAACA,SAAS,MAAM,GAAG,EAAE;QAC1C,IAAIE,SAASP;QACb,IAAIQ,SAAkCV;QACtC,KAAK,MAAMW,WAAWJ,SAAS,KAAK,CAAC,GAAG,IAAK;YACzC,MAAMK,WAAWH,MAAM,CAACE,QAAQ;YAChC,MAAME,WAAWH,MAAM,CAACC,QAAQ;YAChC,IAAIG;YACJ,IAAIlB,SAASgB,aAAaT,OAAO,GAAG,CAACS,WACjCE,OAAOF;iBACJ;gBACHE,OAAOlB,SAASiB,YAAY;oBAAE,GAAGA,QAAQ;gBAAC,IAAI,CAAC;gBAC/CV,OAAO,GAAG,CAACW;YACf;YACAL,MAAM,CAACE,QAAQ,GAAGG;YAClBL,SAASK;YACTJ,SAASd,SAASiB,YAAYA,WAAW,CAAC;QAC9C;QACAJ,MAAM,CAACD,KAAK,GAAGX;IACnB;IACA,OAAOK;AACX"}

package/features/wrappers/ApproveCmsEntryReviewStep/ApproveCmsEntryReviewStepUseCase.d.ts

@@ -0,0 +1,13 @@
+import { ApproveReviewStepUseCase } from "@webiny/api-workflows/features/review/ApproveReviewStep/index.js";
+import { CmsEntryReviewGuardService } from "../CmsEntryReviewGuardService/index.js";
+import { ApproveCmsEntryReviewStepUseCase as UseCase } from "./abstractions.js";
+declare class ApproveCmsEntryReviewStepUseCaseImpl implements UseCase.Interface {
+    private guard;
+    private engine;
+    constructor(guard: CmsEntryReviewGuardService.Interface, engine: ApproveReviewStepUseCase.Interface);
+    execute(input: UseCase.Input): UseCase.Return;
+}
+export declare const ApproveCmsEntryReviewStepUseCase: typeof ApproveCmsEntryReviewStepUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IApproveCmsEntryReviewStepUseCase>;
+};
+export {};

package/features/wrappers/ApproveCmsEntryReviewStep/ApproveCmsEntryReviewStepUseCase.js

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import { ApproveReviewStepUseCase } from "@webiny/api-workflows/features/review/ApproveReviewStep/index.js";
+import { CmsEntryReviewGuardService } from "../CmsEntryReviewGuardService/index.js";
+import { ApproveCmsEntryReviewStepUseCase } from "./abstractions.js";
+class ApproveCmsEntryReviewStepUseCaseImpl {
+    constructor(guard, engine){
+        this.guard = guard;
+        this.engine = engine;
+    }
+    async execute(input) {
+        const authorized = await this.guard.authorize({
+            reviewId: input.reviewId,
+            action: "approve this step"
+        });
+        if (authorized.isFail()) return Result.fail(authorized.error);
+        const { viewer } = authorized.value;
+        return this.engine.execute({
+            reviewId: input.reviewId,
+            stepId: input.stepId,
+            actor: viewer.actor,
+            actorTeamIds: viewer.teamIds,
+            comment: input.comment ?? null
+        });
+    }
+}
+const ApproveCmsEntryReviewStepUseCase_ApproveCmsEntryReviewStepUseCase = ApproveCmsEntryReviewStepUseCase.createImplementation({
+    implementation: ApproveCmsEntryReviewStepUseCaseImpl,
+    dependencies: [
+        CmsEntryReviewGuardService,
+        ApproveReviewStepUseCase
+    ]
+});
+export { ApproveCmsEntryReviewStepUseCase_ApproveCmsEntryReviewStepUseCase as ApproveCmsEntryReviewStepUseCase };
+
+//# sourceMappingURL=ApproveCmsEntryReviewStepUseCase.js.map

package/features/wrappers/ApproveCmsEntryReviewStep/ApproveCmsEntryReviewStepUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wrappers/ApproveCmsEntryReviewStep/ApproveCmsEntryReviewStepUseCase.js","sources":["../../../../src/features/wrappers/ApproveCmsEntryReviewStep/ApproveCmsEntryReviewStepUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ApproveReviewStepUseCase } from \"@webiny/api-workflows/features/review/ApproveReviewStep/index.js\";\nimport { CmsEntryReviewGuardService } from \"../CmsEntryReviewGuardService/index.js\";\nimport { ApproveCmsEntryReviewStepUseCase as UseCase } from \"./abstractions.js\";\n\nclass ApproveCmsEntryReviewStepUseCaseImpl implements UseCase.Interface {\n    public constructor(\n        private guard: CmsEntryReviewGuardService.Interface,\n        private engine: ApproveReviewStepUseCase.Interface\n    ) {}\n\n    public async execute(input: UseCase.Input): UseCase.Return {\n        const authorized = await this.guard.authorize({\n            reviewId: input.reviewId,\n            action: \"approve this step\"\n        });\n        if (authorized.isFail()) {\n            return Result.fail(authorized.error);\n        }\n\n        const { viewer } = authorized.value;\n        return this.engine.execute({\n            reviewId: input.reviewId,\n            stepId: input.stepId,\n            actor: viewer.actor,\n            actorTeamIds: viewer.teamIds,\n            comment: input.comment ?? null\n        });\n    }\n}\n\nexport const ApproveCmsEntryReviewStepUseCase = UseCase.createImplementation({\n    implementation: ApproveCmsEntryReviewStepUseCaseImpl,\n    dependencies: [CmsEntryReviewGuardService, ApproveReviewStepUseCase]\n});\n"],"names":["ApproveCmsEntryReviewStepUseCaseImpl","guard","engine","input","authorized","Result","viewer","ApproveCmsEntryReviewStepUseCase","UseCase","CmsEntryReviewGuardService","ApproveReviewStepUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YACYC,KAA2C,EAC3CC,MAA0C,CACpD;aAFUD,KAAK,GAALA;aACAC,MAAM,GAANA;IACT;IAEH,MAAa,QAAQC,KAAoB,EAAkB;QACvD,MAAMC,aAAa,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;YAC1C,UAAUD,MAAM,QAAQ;YACxB,QAAQ;QACZ;QACA,IAAIC,WAAW,MAAM,IACjB,OAAOC,OAAO,IAAI,CAACD,WAAW,KAAK;QAGvC,MAAM,EAAEE,MAAM,EAAE,GAAGF,WAAW,KAAK;QACnC,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;YACvB,UAAUD,MAAM,QAAQ;YACxB,QAAQA,MAAM,MAAM;YACpB,OAAOG,OAAO,KAAK;YACnB,cAAcA,OAAO,OAAO;YAC5B,SAASH,MAAM,OAAO,IAAI;QAC9B;IACJ;AACJ;AAEO,MAAMI,oEAAmCC,iCAAAA,oBAA4B,CAAC;IACzE,gBAAgBR;IAChB,cAAc;QAACS;QAA4BC;KAAyB;AACxE"}

package/features/wrappers/ApproveCmsEntryReviewStep/abstractions.d.ts

@@ -0,0 +1,26 @@
+import { type Result } from "@webiny/feature/api";
+import type { ReviewData } from "@webiny/api-workflows/domain/review/types.js";
+import type { ApproveReviewStepUseCase } from "@webiny/api-workflows/features/review/ApproveReviewStep/index.js";
+import type { CmsEntryReviewGuardService } from "../CmsEntryReviewGuardService/index.js";
+export interface ApproveCmsEntryReviewStepInput {
+    reviewId: string;
+    stepId: string;
+    comment?: string | null;
+}
+export interface IApproveCmsEntryReviewStepUseCaseErrors {
+    guard: CmsEntryReviewGuardService.Error;
+    approve: ApproveReviewStepUseCase.Error;
+}
+type UseCaseError = IApproveCmsEntryReviewStepUseCaseErrors[keyof IApproveCmsEntryReviewStepUseCaseErrors];
+export interface IApproveCmsEntryReviewStepUseCase {
+    execute(input: ApproveCmsEntryReviewStepInput): Promise<Result<ReviewData, UseCaseError>>;
+}
+/** Approve the CMS review step the user owns (spec 5.1): read access here, ownership in the engine. */
+export declare const ApproveCmsEntryReviewStepUseCase: import("@webiny/di").Abstraction<IApproveCmsEntryReviewStepUseCase>;
+export declare namespace ApproveCmsEntryReviewStepUseCase {
+    type Interface = IApproveCmsEntryReviewStepUseCase;
+    type Input = ApproveCmsEntryReviewStepInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<ReviewData, UseCaseError>>;
+}
+export {};

package/features/wrappers/ApproveCmsEntryReviewStep/abstractions.js

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

package/features/wrappers/ApproveCmsEntryReviewStep/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wrappers/ApproveCmsEntryReviewStep/abstractions.js","sources":["../../../../src/features/wrappers/ApproveCmsEntryReviewStep/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ReviewData } from \"@webiny/api-workflows/domain/review/types.js\";\nimport type { ApproveReviewStepUseCase } from \"@webiny/api-workflows/features/review/ApproveReviewStep/index.js\";\nimport type { CmsEntryReviewGuardService } from \"../CmsEntryReviewGuardService/index.js\";\n\nexport interface ApproveCmsEntryReviewStepInput {\n    reviewId: string;\n    stepId: string;\n    comment?: string | null;\n}\n\nexport interface IApproveCmsEntryReviewStepUseCaseErrors {\n    guard: CmsEntryReviewGuardService.Error;\n    approve: ApproveReviewStepUseCase.Error;\n}\n\ntype UseCaseError =\n    IApproveCmsEntryReviewStepUseCaseErrors[keyof IApproveCmsEntryReviewStepUseCaseErrors];\n\nexport interface IApproveCmsEntryReviewStepUseCase {\n    execute(input: ApproveCmsEntryReviewStepInput): Promise<Result<ReviewData, UseCaseError>>;\n}\n\n/** Approve the CMS review step the user owns (spec 5.1): read access here, ownership in the engine. */\nexport const ApproveCmsEntryReviewStepUseCase =\n    createAbstraction<IApproveCmsEntryReviewStepUseCase>(\"ApproveCmsEntryReviewStepUseCase\");\n\nexport namespace ApproveCmsEntryReviewStepUseCase {\n    export type Interface = IApproveCmsEntryReviewStepUseCase;\n    export type Input = ApproveCmsEntryReviewStepInput;\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<ReviewData, UseCaseError>>;\n}\n"],"names":["ApproveCmsEntryReviewStepUseCase","createAbstraction"],"mappings":";AAwBO,MAAMA,mCACTC,kBAAqD"}

package/features/wrappers/ApproveCmsEntryReviewStep/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ApproveCmsEntryReviewStepFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/wrappers/ApproveCmsEntryReviewStep/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ApproveCmsEntryReviewStepUseCase } from "./ApproveCmsEntryReviewStepUseCase.js";
+const ApproveCmsEntryReviewStepFeature = createFeature({
+    name: "CmsWorkflows/ApproveCmsEntryReviewStep",
+    register (container) {
+        container.register(ApproveCmsEntryReviewStepUseCase);
+    }
+});
+export { ApproveCmsEntryReviewStepFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/wrappers/ApproveCmsEntryReviewStep/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wrappers/ApproveCmsEntryReviewStep/feature.js","sources":["../../../../src/features/wrappers/ApproveCmsEntryReviewStep/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ApproveCmsEntryReviewStepUseCase } from \"./ApproveCmsEntryReviewStepUseCase.js\";\n\nexport const ApproveCmsEntryReviewStepFeature = createFeature({\n    name: \"CmsWorkflows/ApproveCmsEntryReviewStep\",\n    register(container) {\n        container.register(ApproveCmsEntryReviewStepUseCase);\n    }\n});\n"],"names":["ApproveCmsEntryReviewStepFeature","createFeature","container","ApproveCmsEntryReviewStepUseCase"],"mappings":";;AAGO,MAAMA,mCAAmCC,cAAc;IAC1D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/wrappers/ApproveCmsEntryReviewStep/index.d.ts

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

package/features/wrappers/ApproveCmsEntryReviewStep/index.js

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

package/features/wrappers/CancelCmsEntryReview/CancelCmsEntryReviewUseCase.d.ts

@@ -0,0 +1,13 @@
+import { CancelReviewUseCase } from "@webiny/api-workflows/features/review/CancelReview/index.js";
+import { CmsEntryReviewGuardService } from "../CmsEntryReviewGuardService/index.js";
+import { CancelCmsEntryReviewUseCase as UseCase } from "./abstractions.js";
+declare class CancelCmsEntryReviewUseCaseImpl implements UseCase.Interface {
+    private guard;
+    private cancelReview;
+    constructor(guard: CmsEntryReviewGuardService.Interface, cancelReview: CancelReviewUseCase.Interface);
+    execute(input: UseCase.Input): UseCase.Return;
+}
+export declare const CancelCmsEntryReviewUseCase: typeof CancelCmsEntryReviewUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICancelCmsEntryReviewUseCase>;
+};
+export {};

package/features/wrappers/CancelCmsEntryReview/CancelCmsEntryReviewUseCase.js

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { CancelReviewUseCase } from "@webiny/api-workflows/features/review/CancelReview/index.js";
+import { canCancelByPermission } from "@webiny/api-workflows/domain/review/canCancelByPermission.js";
+import { WorkflowsNotAuthorizedError } from "@webiny/api-workflows/domain/permissions/errors.js";
+import { CmsEntryReviewGuardService } from "../CmsEntryReviewGuardService/index.js";
+import { CancelCmsEntryReviewUseCase } from "./abstractions.js";
+class CancelCmsEntryReviewUseCaseImpl {
+    constructor(guard, cancelReview){
+        this.guard = guard;
+        this.cancelReview = cancelReview;
+    }
+    async execute(input) {
+        const authorized = await this.guard.authorize({
+            reviewId: input.reviewId,
+            action: "cancel this review"
+        });
+        if (authorized.isFail()) return Result.fail(authorized.error);
+        const { review, viewer } = authorized.value;
+        if (!canCancelByPermission(review, viewer)) return Result.fail(new WorkflowsNotAuthorizedError({
+            action: "cancel a review requested by someone else"
+        }));
+        return this.cancelReview.execute({
+            reviewId: input.reviewId,
+            actor: viewer.actor
+        });
+    }
+}
+const CancelCmsEntryReviewUseCase_CancelCmsEntryReviewUseCase = CancelCmsEntryReviewUseCase.createImplementation({
+    implementation: CancelCmsEntryReviewUseCaseImpl,
+    dependencies: [
+        CmsEntryReviewGuardService,
+        CancelReviewUseCase
+    ]
+});
+export { CancelCmsEntryReviewUseCase_CancelCmsEntryReviewUseCase as CancelCmsEntryReviewUseCase };
+
+//# sourceMappingURL=CancelCmsEntryReviewUseCase.js.map

package/features/wrappers/CancelCmsEntryReview/CancelCmsEntryReviewUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wrappers/CancelCmsEntryReview/CancelCmsEntryReviewUseCase.js","sources":["../../../../src/features/wrappers/CancelCmsEntryReview/CancelCmsEntryReviewUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CancelReviewUseCase } from \"@webiny/api-workflows/features/review/CancelReview/index.js\";\nimport { canCancelByPermission } from \"@webiny/api-workflows/domain/review/canCancelByPermission.js\";\nimport { WorkflowsNotAuthorizedError } from \"@webiny/api-workflows/domain/permissions/errors.js\";\nimport { CmsEntryReviewGuardService } from \"../CmsEntryReviewGuardService/index.js\";\nimport { CancelCmsEntryReviewUseCase as UseCase } from \"./abstractions.js\";\n\nclass CancelCmsEntryReviewUseCaseImpl implements UseCase.Interface {\n    public constructor(\n        private guard: CmsEntryReviewGuardService.Interface,\n        private cancelReview: CancelReviewUseCase.Interface\n    ) {}\n\n    public async execute(input: UseCase.Input): UseCase.Return {\n        const authorized = await this.guard.authorize({\n            reviewId: input.reviewId,\n            action: \"cancel this review\"\n        });\n        if (authorized.isFail()) {\n            return Result.fail(authorized.error);\n        }\n\n        const { review, viewer } = authorized.value;\n        // Permission only: the review's state is the engine's to report (1b R41).\n        if (!canCancelByPermission(review, viewer)) {\n            return Result.fail(\n                new WorkflowsNotAuthorizedError({\n                    action: \"cancel a review requested by someone else\"\n                })\n            );\n        }\n\n        return this.cancelReview.execute({ reviewId: input.reviewId, actor: viewer.actor });\n    }\n}\n\nexport const CancelCmsEntryReviewUseCase = UseCase.createImplementation({\n    implementation: CancelCmsEntryReviewUseCaseImpl,\n    dependencies: [CmsEntryReviewGuardService, CancelReviewUseCase]\n});\n"],"names":["CancelCmsEntryReviewUseCaseImpl","guard","cancelReview","input","authorized","Result","review","viewer","canCancelByPermission","WorkflowsNotAuthorizedError","CancelCmsEntryReviewUseCase","UseCase","CmsEntryReviewGuardService","CancelReviewUseCase"],"mappings":";;;;;;AAOA,MAAMA;IACF,YACYC,KAA2C,EAC3CC,YAA2C,CACrD;aAFUD,KAAK,GAALA;aACAC,YAAY,GAAZA;IACT;IAEH,MAAa,QAAQC,KAAoB,EAAkB;QACvD,MAAMC,aAAa,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;YAC1C,UAAUD,MAAM,QAAQ;YACxB,QAAQ;QACZ;QACA,IAAIC,WAAW,MAAM,IACjB,OAAOC,OAAO,IAAI,CAACD,WAAW,KAAK;QAGvC,MAAM,EAAEE,MAAM,EAAEC,MAAM,EAAE,GAAGH,WAAW,KAAK;QAE3C,IAAI,CAACI,sBAAsBF,QAAQC,SAC/B,OAAOF,OAAO,IAAI,CACd,IAAII,4BAA4B;YAC5B,QAAQ;QACZ;QAIR,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YAAE,UAAUN,MAAM,QAAQ;YAAE,OAAOI,OAAO,KAAK;QAAC;IACrF;AACJ;AAEO,MAAMG,0DAA8BC,4BAAAA,oBAA4B,CAAC;IACpE,gBAAgBX;IAChB,cAAc;QAACY;QAA4BC;KAAoB;AACnE"}

package/features/wrappers/CancelCmsEntryReview/abstractions.d.ts

@@ -0,0 +1,30 @@
+import { type Result } from "@webiny/feature/api";
+import type { ReviewData } from "@webiny/api-workflows/domain/review/types.js";
+import type { WorkflowsNotAuthorizedError } from "@webiny/api-workflows/domain/permissions/errors.js";
+import type { CancelReviewUseCase } from "@webiny/api-workflows/features/review/CancelReview/index.js";
+import type { CmsEntryReviewGuardService } from "../CmsEntryReviewGuardService/index.js";
+export interface CancelCmsEntryReviewInput {
+    reviewId: string;
+}
+export interface ICancelCmsEntryReviewUseCaseErrors {
+    guard: CmsEntryReviewGuardService.Error;
+    notAuthorized: WorkflowsNotAuthorizedError;
+    cancel: CancelReviewUseCase.Error;
+}
+type UseCaseError = ICancelCmsEntryReviewUseCaseErrors[keyof ICancelCmsEntryReviewUseCaseErrors];
+export interface ICancelCmsEntryReviewUseCase {
+    execute(input: CancelCmsEntryReviewInput): Promise<Result<ReviewData, UseCaseError>>;
+}
+/**
+ * Cancel a CMS review (spec 5.1, D25, D133 point 7): read access to the target and the requester
+ * or `workflows.reassign` (`canCancelByPermission`, 1b R41). Finished reviews fail in the engine
+ * with `Workflows/Review/InvalidState`.
+ */
+export declare const CancelCmsEntryReviewUseCase: import("@webiny/di").Abstraction<ICancelCmsEntryReviewUseCase>;
+export declare namespace CancelCmsEntryReviewUseCase {
+    type Interface = ICancelCmsEntryReviewUseCase;
+    type Input = CancelCmsEntryReviewInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<ReviewData, UseCaseError>>;
+}
+export {};

package/features/wrappers/CancelCmsEntryReview/abstractions.js

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

package/features/wrappers/CancelCmsEntryReview/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wrappers/CancelCmsEntryReview/abstractions.js","sources":["../../../../src/features/wrappers/CancelCmsEntryReview/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ReviewData } from \"@webiny/api-workflows/domain/review/types.js\";\nimport type { WorkflowsNotAuthorizedError } from \"@webiny/api-workflows/domain/permissions/errors.js\";\nimport type { CancelReviewUseCase } from \"@webiny/api-workflows/features/review/CancelReview/index.js\";\nimport type { CmsEntryReviewGuardService } from \"../CmsEntryReviewGuardService/index.js\";\n\nexport interface CancelCmsEntryReviewInput {\n    reviewId: string;\n}\n\nexport interface ICancelCmsEntryReviewUseCaseErrors {\n    guard: CmsEntryReviewGuardService.Error;\n    notAuthorized: WorkflowsNotAuthorizedError;\n    cancel: CancelReviewUseCase.Error;\n}\n\ntype UseCaseError = ICancelCmsEntryReviewUseCaseErrors[keyof ICancelCmsEntryReviewUseCaseErrors];\n\nexport interface ICancelCmsEntryReviewUseCase {\n    execute(input: CancelCmsEntryReviewInput): Promise<Result<ReviewData, UseCaseError>>;\n}\n\n/**\n * Cancel a CMS review (spec 5.1, D25, D133 point 7): read access to the target and the requester\n * or `workflows.reassign` (`canCancelByPermission`, 1b R41). Finished reviews fail in the engine\n * with `Workflows/Review/InvalidState`.\n */\nexport const CancelCmsEntryReviewUseCase = createAbstraction<ICancelCmsEntryReviewUseCase>(\n    \"CancelCmsEntryReviewUseCase\"\n);\n\nexport namespace CancelCmsEntryReviewUseCase {\n    export type Interface = ICancelCmsEntryReviewUseCase;\n    export type Input = CancelCmsEntryReviewInput;\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<ReviewData, UseCaseError>>;\n}\n"],"names":["CancelCmsEntryReviewUseCase","createAbstraction"],"mappings":";AA2BO,MAAMA,8BAA8BC,kBACvC"}

package/features/wrappers/CancelCmsEntryReview/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const CancelCmsEntryReviewFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/wrappers/CancelCmsEntryReview/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { CancelCmsEntryReviewUseCase } from "./CancelCmsEntryReviewUseCase.js";
+const CancelCmsEntryReviewFeature = createFeature({
+    name: "CmsWorkflows/CancelCmsEntryReview",
+    register (container) {
+        container.register(CancelCmsEntryReviewUseCase);
+    }
+});
+export { CancelCmsEntryReviewFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/wrappers/CancelCmsEntryReview/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wrappers/CancelCmsEntryReview/feature.js","sources":["../../../../src/features/wrappers/CancelCmsEntryReview/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CancelCmsEntryReviewUseCase } from \"./CancelCmsEntryReviewUseCase.js\";\n\nexport const CancelCmsEntryReviewFeature = createFeature({\n    name: \"CmsWorkflows/CancelCmsEntryReview\",\n    register(container) {\n        container.register(CancelCmsEntryReviewUseCase);\n    }\n});\n"],"names":["CancelCmsEntryReviewFeature","createFeature","container","CancelCmsEntryReviewUseCase"],"mappings":";;AAGO,MAAMA,8BAA8BC,cAAc;IACrD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/wrappers/CancelCmsEntryReview/index.d.ts

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

package/features/wrappers/CancelCmsEntryReview/index.js

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

package/features/wrappers/CancelCmsEntryReviewsForDelete/CancelCmsEntryReviewsForDeleteUseCase.d.ts

@@ -0,0 +1,19 @@
+import { CurrentReviewViewer } from "@webiny/api-workflows/features/identity/CurrentReviewViewer/index.js";
+import { ListTargetReviewsUseCase } from "@webiny/api-workflows/features/review/ListTargetReviews/index.js";
+import { CancelTargetReviewsUseCase } from "@webiny/api-workflows/features/review/CancelTargetReviews/index.js";
+import { CmsEntryTargetReader } from "../../../features/target/CmsEntryTargetReader/index.js";
+import { CmsEntryAccess } from "../../../features/target/CmsEntryAccess/index.js";
+import { CancelCmsEntryReviewsForDeleteUseCase as UseCase } from "./abstractions.js";
+declare class CancelCmsEntryReviewsForDeleteUseCaseImpl implements UseCase.Interface {
+    private viewer;
+    private listTargetReviews;
+    private targets;
+    private access;
+    private cancelTargetReviews;
+    constructor(viewer: CurrentReviewViewer.Interface, listTargetReviews: ListTargetReviewsUseCase.Interface, targets: CmsEntryTargetReader.Interface, access: CmsEntryAccess.Interface, cancelTargetReviews: CancelTargetReviewsUseCase.Interface);
+    execute(input: UseCase.Input): UseCase.Return;
+}
+export declare const CancelCmsEntryReviewsForDeleteUseCase: typeof CancelCmsEntryReviewsForDeleteUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICancelCmsEntryReviewsForDeleteUseCase>;
+};
+export {};