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

package/domain/assignment/errors.js

@@ -0,0 +1,9 @@
+import { PersistenceError } from "../PersistenceError.js";
+class AssignmentPersistenceError extends PersistenceError {
+    constructor(error){
+        super("The review assignments could not be read or saved.", error), this.code = "Workflows/Assignment/Persistence";
+    }
+}
+export { AssignmentPersistenceError };
+
+//# sourceMappingURL=errors.js.map

package/domain/assignment/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/assignment/errors.js","sources":["../../../src/domain/assignment/errors.ts"],"sourcesContent":["import type { PersistenceErrorSource } from \"~/domain/PersistenceErrorSource.js\";\nimport { PersistenceError } from \"~/domain/PersistenceError.js\";\n\nexport class AssignmentPersistenceError extends PersistenceError {\n    override readonly code = \"Workflows/Assignment/Persistence\" as const;\n\n    constructor(error: PersistenceErrorSource) {\n        super(\"The review assignments could not be read or saved.\", error);\n    }\n}\n"],"names":["AssignmentPersistenceError","PersistenceError","error"],"mappings":";AAGO,MAAMA,mCAAmCC;IAG5C,YAAYC,KAA6B,CAAE;QACvC,KAAK,CAAC,sDAAsDA,QAAAA,IAAAA,CAH9C,IAAI,GAAG;IAIzB;AACJ"}

package/domain/assignment/redactAssignmentRecords.d.ts

@@ -0,0 +1,8 @@
+import type { WorkflowsPermissionSet } from "../../domain/permissions/types.js";
+import type { AssignmentRecord } from "./types.js";
+/**
+ * The assignment entries one viewer may see (spec 8, D89, D127, R96). Pure. `editor` and
+ * `reassign` (full access sets both) see every record; everyone else sees only the outcomes,
+ * because a skip names a person and why they were passed over. Order is kept.
+ */
+export declare const redactAssignmentRecords: <TRecord extends AssignmentRecord>(records: TRecord[], permissions: WorkflowsPermissionSet) => TRecord[];

package/domain/assignment/redactAssignmentRecords.js

@@ -0,0 +1,9 @@
+const redactAssignmentRecords = (records, permissions)=>{
+    if (permissions.editor || permissions.reassign) return [
+        ...records
+    ];
+    return records.filter((record)=>"skip" !== record.kind);
+};
+export { redactAssignmentRecords };
+
+//# sourceMappingURL=redactAssignmentRecords.js.map

package/domain/assignment/redactAssignmentRecords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/assignment/redactAssignmentRecords.js","sources":["../../../src/domain/assignment/redactAssignmentRecords.ts"],"sourcesContent":["import type { WorkflowsPermissionSet } from \"~/domain/permissions/types.js\";\nimport type { AssignmentRecord } from \"./types.js\";\n\n/**\n * The assignment entries one viewer may see (spec 8, D89, D127, R96). Pure. `editor` and\n * `reassign` (full access sets both) see every record; everyone else sees only the outcomes,\n * because a skip names a person and why they were passed over. Order is kept.\n */\nexport const redactAssignmentRecords = <TRecord extends AssignmentRecord>(\n    records: TRecord[],\n    permissions: WorkflowsPermissionSet\n): TRecord[] => {\n    if (permissions.editor || permissions.reassign) {\n        return [...records];\n    }\n    return records.filter(record => record.kind !== \"skip\");\n};\n"],"names":["redactAssignmentRecords","records","permissions","record"],"mappings":"AAQO,MAAMA,0BAA0B,CACnCC,SACAC;IAEA,IAAIA,YAAY,MAAM,IAAIA,YAAY,QAAQ,EAC1C,OAAO;WAAID;KAAQ;IAEvB,OAAOA,QAAQ,MAAM,CAACE,CAAAA,SAAUA,AAAgB,WAAhBA,OAAO,IAAI;AAC/C"}

package/domain/assignment/toAssignmentRecordValues.d.ts

@@ -0,0 +1,10 @@
+import type { ReviewFact } from "../../domain/review/facts.js";
+import type { ReviewData } from "../../domain/review/types.js";
+import type { AssignmentRecordValues } from "./types.js";
+/**
+ * The assignment-log records one saved fact produces, in decision order (spec 4.3, 6, R117).
+ * Pure. Step reached carries the resolver's skips and outcome; start, take over and reassign carry one
+ * outcome. `assignedOn` is the fact's time, which is the reach `now`. Every fact type has a case,
+ * so a new fact does not compile until it says whether it writes records.
+ */
+export declare const toAssignmentRecordValues: (review: ReviewData, fact: ReviewFact) => AssignmentRecordValues[];

package/domain/assignment/toAssignmentRecordValues.js

@@ -0,0 +1,29 @@
+const toAssignmentRecordValues = (review, fact)=>{
+    switch(fact.type){
+        case "stepReached":
+        case "stepStarted":
+        case "stepTakenOver":
+        case "stepReassigned":
+            return fact.records.map((record)=>({
+                    ...record,
+                    by: record.by ? {
+                        ...record.by
+                    } : null,
+                    reviewId: review.id,
+                    workflowId: review.workflowId,
+                    stepId: fact.change.stepId,
+                    assignedOn: fact.occurredOn
+                }));
+        case "requested":
+        case "stepApproved":
+        case "stepRejected":
+        case "stepFailed":
+        case "stepRestarted":
+        case "cancelled":
+        case "approved":
+            return [];
+    }
+};
+export { toAssignmentRecordValues };
+
+//# sourceMappingURL=toAssignmentRecordValues.js.map

package/domain/assignment/toAssignmentRecordValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/assignment/toAssignmentRecordValues.js","sources":["../../../src/domain/assignment/toAssignmentRecordValues.ts"],"sourcesContent":["import type { ReviewFact } from \"~/domain/review/facts.js\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\nimport type { AssignmentRecordValues } from \"./types.js\";\n\n/**\n * The assignment-log records one saved fact produces, in decision order (spec 4.3, 6, R117).\n * Pure. Step reached carries the resolver's skips and outcome; start, take over and reassign carry one\n * outcome. `assignedOn` is the fact's time, which is the reach `now`. Every fact type has a case,\n * so a new fact does not compile until it says whether it writes records.\n */\nexport const toAssignmentRecordValues = (\n    review: ReviewData,\n    fact: ReviewFact\n): AssignmentRecordValues[] => {\n    switch (fact.type) {\n        case \"stepReached\":\n        case \"stepStarted\":\n        case \"stepTakenOver\":\n        case \"stepReassigned\":\n            return fact.records.map((record): AssignmentRecordValues => {\n                return {\n                    ...record,\n                    by: record.by ? { ...record.by } : null,\n                    reviewId: review.id,\n                    workflowId: review.workflowId,\n                    stepId: fact.change.stepId,\n                    assignedOn: fact.occurredOn\n                };\n            });\n        case \"requested\":\n        case \"stepApproved\":\n        case \"stepRejected\":\n        case \"stepFailed\":\n        case \"stepRestarted\":\n        case \"cancelled\":\n        case \"approved\":\n            return [];\n    }\n};\n"],"names":["toAssignmentRecordValues","review","fact","record"],"mappings":"AAUO,MAAMA,2BAA2B,CACpCC,QACAC;IAEA,OAAQA,KAAK,IAAI;QACb,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACD,OAAOA,KAAK,OAAO,CAAC,GAAG,CAAC,CAACC,SACd;oBACH,GAAGA,MAAM;oBACT,IAAIA,OAAO,EAAE,GAAG;wBAAE,GAAGA,OAAO,EAAE;oBAAC,IAAI;oBACnC,UAAUF,OAAO,EAAE;oBACnB,YAAYA,OAAO,UAAU;oBAC7B,QAAQC,KAAK,MAAM,CAAC,MAAM;oBAC1B,YAAYA,KAAK,UAAU;gBAC/B;QAER,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACD,OAAO,EAAE;IACjB;AACJ"}

package/domain/assignment/types.d.ts

@@ -0,0 +1,63 @@
+import type { Actor, ReviewData, ReviewStep, ReviewViewerFlags } from "../../domain/review/types.js";
+/**
+ * `outcome`: who got the step (pick, rule, strategy, pool, start, take over, reassign). `skip`: a
+ * person passed over, with the reason (requester, excluded, not a member, cannot read); only
+ * viewers with `editor` or `reassign` see these (D89, D127).
+ */
+export type AssignmentRecordKind = "outcome" | "skip";
+/**
+ * Why a step has its owner (R109). `rule`: a rule's user target; a rule's team target leaves the
+ * strategy name or `pool` with the rule in `ruleId`. `poolStart`, `takeOver` and `reassign` are
+ * the transitions that change the owner after the step was reached.
+ */
+export type AssignmentSource = "picked" | "rule" | "roundRobin" | "leastLoaded" | "pool" | "poolStart" | "takeOver" | "reassign";
+/**
+ * One assignment decision, before it is tied to a saved review (R117): the resolver and the
+ * transitions produce these, `ReviewSaver` writes them after the save.
+ */
+export interface AssignmentDecision {
+    kind: AssignmentRecordKind;
+    /**
+     * The owner (outcome) or the person passed over (skip); `null` for the pool and for a skipped
+     * rule whose team target is not one of the step's teams.
+     */
+    userId: string | null;
+    source: AssignmentSource;
+    /** The rule that decided or was skipped; `null` otherwise. */
+    ruleId: string | null;
+    /** Who acted, for take over and reassign. */
+    by: Actor | null;
+    /**
+     * A fixed text for skips and pool fall-through (R112, R116). Never an exclusion's own reason
+     * (D89, D97).
+     */
+    reason: string | null;
+}
+/** One assignment-log record (spec 4.3, D20, D45, D127), written after the review save (R117). */
+export interface AssignmentRecordValues extends AssignmentDecision {
+    reviewId: string;
+    workflowId: string;
+    stepId: string;
+    assignedOn: string;
+}
+export interface AssignmentRecord extends AssignmentRecordValues {
+    id: string;
+}
+/** A record as the review screens read it (D127, R251). */
+export interface AssignmentEntry extends AssignmentRecord {
+    /** The user's display name; `null` without a user, for a deleted user or when it could not be read. */
+    userDisplayName: string | null;
+}
+/** A review step with its assignment-log entries, newest first (D127). */
+export interface ReviewStepWithAssignments extends ReviewStep {
+    assignments: AssignmentEntry[];
+}
+/** A review as the get-review wrappers return it: each step carries its entries (R96). */
+export interface ReviewWithAssignments extends Omit<ReviewData, "steps"> {
+    steps: ReviewStepWithAssignments[];
+}
+/** The get-review wrappers' value: the review with entries and the viewer's flags (spec 5.3). */
+export interface ReviewWithAssignmentsAndViewerFlags {
+    review: ReviewWithAssignments;
+    flags: ReviewViewerFlags;
+}

package/domain/automation/automationStepConfigSchema.d.ts

@@ -0,0 +1,17 @@
+import zod from "zod";
+/** The stored config of an "automation" step (R133). */
+export interface AutomationStepConfig {
+    automationId: string;
+    /** Validated against the definition's `settingsSchema`; stored as the author entered them and parsed again on every use. */
+    settings: Record<string, unknown>;
+}
+/**
+ * The shell of an automation step's config: which automation, and its settings. The settings
+ * themselves are validated against the chosen definition's `settingsSchema`, not here. This is
+ * the step type's `configSchema` (what `listStepTypes` returns); the editor gets the settings
+ * schema per automation from `listAutomationDefinitions`.
+ */
+export declare const automationStepConfigSchema: zod.ZodObject<{
+    automationId: zod.ZodString;
+    settings: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+}, zod.core.$strip>;

package/domain/automation/automationStepConfigSchema.js

@@ -0,0 +1,8 @@
+import zod from "zod";
+const automationStepConfigSchema = zod.object({
+    automationId: zod.string().min(1),
+    settings: zod.record(zod.string(), zod.unknown())
+});
+export { automationStepConfigSchema };
+
+//# sourceMappingURL=automationStepConfigSchema.js.map

package/domain/automation/automationStepConfigSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/automation/automationStepConfigSchema.js","sources":["../../../src/domain/automation/automationStepConfigSchema.ts"],"sourcesContent":["import zod from \"zod\";\n\n/** The stored config of an \"automation\" step (R133). */\nexport interface AutomationStepConfig {\n    automationId: string;\n    /** Validated against the definition's `settingsSchema`; stored as the author entered them and parsed again on every use. */\n    settings: Record<string, unknown>;\n}\n\n/**\n * The shell of an automation step's config: which automation, and its settings. The settings\n * themselves are validated against the chosen definition's `settingsSchema`, not here. This is\n * the step type's `configSchema` (what `listStepTypes` returns); the editor gets the settings\n * schema per automation from `listAutomationDefinitions`.\n */\nexport const automationStepConfigSchema = zod.object({\n    automationId: zod.string().min(1),\n    settings: zod.record(zod.string(), zod.unknown())\n});\n"],"names":["automationStepConfigSchema","zod"],"mappings":";AAeO,MAAMA,6BAA6BC,IAAI,MAAM,CAAC;IACjD,cAAcA,IAAI,MAAM,GAAG,GAAG,CAAC;IAC/B,UAAUA,IAAI,MAAM,CAACA,IAAI,MAAM,IAAIA,IAAI,OAAO;AAClD"}

package/domain/automation/getAutomationActor.d.ts

@@ -0,0 +1,8 @@
+import type { Actor } from "../../domain/review/types.js";
+/**
+ * The actor of an automation step (spec 5.2, D58, D107, R141): the requester's id and name with
+ * the `automation` type, so the step's owner, its approve and reject facts and its `fail` facts
+ * say who the automation acts for. `identityType` is omitted: an automation is not an identity.
+ * Pure.
+ */
+export declare const getAutomationActor: (requester: Actor) => Actor;

package/domain/automation/getAutomationActor.js

@@ -0,0 +1,8 @@
+const getAutomationActor = (requester)=>({
+        type: "automation",
+        id: requester.id,
+        displayName: requester.displayName
+    });
+export { getAutomationActor };
+
+//# sourceMappingURL=getAutomationActor.js.map

package/domain/automation/getAutomationActor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/automation/getAutomationActor.js","sources":["../../../src/domain/automation/getAutomationActor.ts"],"sourcesContent":["import type { Actor } from \"~/domain/review/types.js\";\n\n/**\n * The actor of an automation step (spec 5.2, D58, D107, R141): the requester's id and name with\n * the `automation` type, so the step's owner, its approve and reject facts and its `fail` facts\n * say who the automation acts for. `identityType` is omitted: an automation is not an identity.\n * Pure.\n */\nexport const getAutomationActor = (requester: Actor): Actor => {\n    return {\n        type: \"automation\",\n        id: requester.id,\n        displayName: requester.displayName\n    };\n};\n"],"names":["getAutomationActor","requester"],"mappings":"AAQO,MAAMA,qBAAqB,CAACC,YACxB;QACH,MAAM;QACN,IAAIA,UAAU,EAAE;QAChB,aAAaA,UAAU,WAAW;IACtC"}

package/domain/automation/getRequesterIdentity.d.ts

@@ -0,0 +1,9 @@
+import { AuthenticatedIdentity } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { Actor } from "../../domain/review/types.js";
+/**
+ * The identity an automation step runs as (D58, D87, R149, R161): the review's requester, with
+ * the requester's identity type (`admin` when it has none) and tenant access. The trigger and
+ * the run handler both use it, so the task's `createdBy` and the handler's identity match.
+ * Pure.
+ */
+export declare const getRequesterIdentity: (requester: Actor) => AuthenticatedIdentity;

package/domain/automation/getRequesterIdentity.js

@@ -0,0 +1,12 @@
+import { AuthenticatedIdentity } from "@webiny/api-core/features/security/IdentityContext/index.js";
+const getRequesterIdentity = (requester)=>new AuthenticatedIdentity({
+        id: requester.id,
+        displayName: requester.displayName,
+        type: requester.identityType ?? "admin",
+        context: {
+            canAccessTenant: true
+        }
+    });
+export { getRequesterIdentity };
+
+//# sourceMappingURL=getRequesterIdentity.js.map

package/domain/automation/getRequesterIdentity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/automation/getRequesterIdentity.js","sources":["../../../src/domain/automation/getRequesterIdentity.ts"],"sourcesContent":["import { AuthenticatedIdentity } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { Actor } from \"~/domain/review/types.js\";\n\n/**\n * The identity an automation step runs as (D58, D87, R149, R161): the review's requester, with\n * the requester's identity type (`admin` when it has none) and tenant access. The trigger and\n * the run handler both use it, so the task's `createdBy` and the handler's identity match.\n * Pure.\n */\nexport const getRequesterIdentity = (requester: Actor): AuthenticatedIdentity => {\n    return new AuthenticatedIdentity({\n        id: requester.id,\n        displayName: requester.displayName,\n        type: requester.identityType ?? \"admin\",\n        context: { canAccessTenant: true }\n    });\n};\n"],"names":["getRequesterIdentity","requester","AuthenticatedIdentity"],"mappings":";AASO,MAAMA,uBAAuB,CAACC,YAC1B,IAAIC,sBAAsB;QAC7B,IAAID,UAAU,EAAE;QAChB,aAAaA,UAAU,WAAW;QAClC,MAAMA,UAAU,YAAY,IAAI;QAChC,SAAS;YAAE,iBAAiB;QAAK;IACrC"}

package/domain/automation/matchesAutomationScope.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether an automation's `models` cover every model of a workflow (D35, R136): `"*"` covers all,
+ * `"<app>.*"` covers the namespace ids starting with `"<app>."`, anything else is an exact
+ * namespace id. A workflow without models is never covered.
+ */
+export declare const matchesAutomationScope: (automationModels: string[], workflowModels: string[]) => boolean;

package/domain/automation/matchesAutomationScope.js

@@ -0,0 +1,16 @@
+const WILDCARD_SUFFIX = ".*";
+const coversModel = (automationModel, workflowModel)=>{
+    if ("*" === automationModel) return true;
+    if (automationModel.endsWith(WILDCARD_SUFFIX) && automationModel.length > WILDCARD_SUFFIX.length) {
+        const prefix = automationModel.slice(0, -1);
+        return workflowModel.startsWith(prefix) && workflowModel.length > prefix.length;
+    }
+    return automationModel === workflowModel;
+};
+const matchesAutomationScope = (automationModels, workflowModels)=>{
+    if (0 === workflowModels.length) return false;
+    return workflowModels.every((workflowModel)=>automationModels.some((automationModel)=>coversModel(automationModel, workflowModel)));
+};
+export { matchesAutomationScope };
+
+//# sourceMappingURL=matchesAutomationScope.js.map

package/domain/automation/matchesAutomationScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/automation/matchesAutomationScope.js","sources":["../../../src/domain/automation/matchesAutomationScope.ts"],"sourcesContent":["const WILDCARD_SUFFIX = \".*\";\n\nconst coversModel = (automationModel: string, workflowModel: string): boolean => {\n    if (automationModel === \"*\") {\n        return true;\n    }\n    if (\n        automationModel.endsWith(WILDCARD_SUFFIX) &&\n        automationModel.length > WILDCARD_SUFFIX.length\n    ) {\n        // \"cms.*\" covers \"cms.article\": the namespace prefix up to and including the dot.\n        const prefix = automationModel.slice(0, -1);\n        return workflowModel.startsWith(prefix) && workflowModel.length > prefix.length;\n    }\n    return automationModel === workflowModel;\n};\n\n/**\n * Whether an automation's `models` cover every model of a workflow (D35, R136): `\"*\"` covers all,\n * `\"<app>.*\"` covers the namespace ids starting with `\"<app>.\"`, anything else is an exact\n * namespace id. A workflow without models is never covered.\n */\nexport const matchesAutomationScope = (\n    automationModels: string[],\n    workflowModels: string[]\n): boolean => {\n    if (workflowModels.length === 0) {\n        return false;\n    }\n    return workflowModels.every(workflowModel => {\n        return automationModels.some(automationModel => {\n            return coversModel(automationModel, workflowModel);\n        });\n    });\n};\n"],"names":["WILDCARD_SUFFIX","coversModel","automationModel","workflowModel","prefix","matchesAutomationScope","automationModels","workflowModels"],"mappings":"AAAA,MAAMA,kBAAkB;AAExB,MAAMC,cAAc,CAACC,iBAAyBC;IAC1C,IAAID,AAAoB,QAApBA,iBACA,OAAO;IAEX,IACIA,gBAAgB,QAAQ,CAACF,oBACzBE,gBAAgB,MAAM,GAAGF,gBAAgB,MAAM,EACjD;QAEE,MAAMI,SAASF,gBAAgB,KAAK,CAAC,GAAG;QACxC,OAAOC,cAAc,UAAU,CAACC,WAAWD,cAAc,MAAM,GAAGC,OAAO,MAAM;IACnF;IACA,OAAOF,oBAAoBC;AAC/B;AAOO,MAAME,yBAAyB,CAClCC,kBACAC;IAEA,IAAIA,AAA0B,MAA1BA,eAAe,MAAM,EACrB,OAAO;IAEX,OAAOA,eAAe,KAAK,CAACJ,CAAAA,gBACjBG,iBAAiB,IAAI,CAACJ,CAAAA,kBAClBD,YAAYC,iBAAiBC;AAGhD"}

package/domain/automation/parseAutomationSettings.d.ts

@@ -0,0 +1,8 @@
+import { Result } from "@webiny/feature/api";
+import type { ZodType } from "zod";
+/**
+ * Parses a step's settings with the definition's `settingsSchema` (R133, R137, R148). Ok is the
+ * parsed value (defaults applied); fail is the first issue as `"<path>: <message>"`, the path
+ * dot-joined and omitted when empty. Save, reach and restart word their own reasons around it.
+ */
+export declare const parseAutomationSettings: (settingsSchema: ZodType, settings: unknown) => Result<unknown, string>;

package/domain/automation/parseAutomationSettings.js

@@ -0,0 +1,11 @@
+import { Result } from "@webiny/feature/api";
+import { parseAutomationSettingsIssue } from "./parseAutomationSettingsIssue.js";
+const parseAutomationSettings = (settingsSchema, settings)=>{
+    const parsed = parseAutomationSettingsIssue(settingsSchema, settings);
+    if (parsed.isOk()) return Result.ok(parsed.value);
+    const { path, message } = parsed.error;
+    return Result.fail(path ? `${path}: ${message}` : message);
+};
+export { parseAutomationSettings };
+
+//# sourceMappingURL=parseAutomationSettings.js.map

package/domain/automation/parseAutomationSettings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/automation/parseAutomationSettings.js","sources":["../../../src/domain/automation/parseAutomationSettings.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport type { ZodType } from \"zod\";\nimport { parseAutomationSettingsIssue } from \"./parseAutomationSettingsIssue.js\";\n\n/**\n * Parses a step's settings with the definition's `settingsSchema` (R133, R137, R148). Ok is the\n * parsed value (defaults applied); fail is the first issue as `\"<path>: <message>\"`, the path\n * dot-joined and omitted when empty. Save, reach and restart word their own reasons around it.\n */\nexport const parseAutomationSettings = (\n    settingsSchema: ZodType,\n    settings: unknown\n): Result<unknown, string> => {\n    const parsed = parseAutomationSettingsIssue(settingsSchema, settings);\n    if (parsed.isOk()) {\n        return Result.ok(parsed.value);\n    }\n    const { path, message } = parsed.error;\n    return Result.fail(path ? `${path}: ${message}` : message);\n};\n"],"names":["parseAutomationSettings","settingsSchema","settings","parsed","parseAutomationSettingsIssue","Result","path","message"],"mappings":";;AASO,MAAMA,0BAA0B,CACnCC,gBACAC;IAEA,MAAMC,SAASC,6BAA6BH,gBAAgBC;IAC5D,IAAIC,OAAO,IAAI,IACX,OAAOE,OAAO,EAAE,CAACF,OAAO,KAAK;IAEjC,MAAM,EAAEG,IAAI,EAAEC,OAAO,EAAE,GAAGJ,OAAO,KAAK;IACtC,OAAOE,OAAO,IAAI,CAACC,OAAO,GAAGA,KAAK,EAAE,EAAEC,SAAS,GAAGA;AACtD"}

package/domain/automation/parseAutomationSettingsIssue.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import type { ZodType } from "zod";
+/** The first problem of a step's automation settings (R267): where it is and what is wrong. */
+export interface AutomationSettingsIssue {
+    /** The zod issue path joined by dots; empty when the issue has no path. */
+    path: string;
+    message: string;
+}
+/**
+ * Parses a step's settings with the definition's `settingsSchema`, like `parseAutomationSettings`,
+ * but fails with the first issue split into its path and message, so the save-time validation can
+ * name the settings field (R267). Ok is the parsed value (defaults applied).
+ */
+export declare const parseAutomationSettingsIssue: (schema: ZodType, settings: unknown) => Result<unknown, AutomationSettingsIssue>;

package/domain/automation/parseAutomationSettingsIssue.js

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+const parseAutomationSettingsIssue = (schema, settings)=>{
+    const parsed = schema.safeParse(settings);
+    if (parsed.success) return Result.ok(parsed.data);
+    const [issue] = parsed.error.issues;
+    const path = issue?.path.map(String).join(".") ?? "";
+    const message = issue?.message ?? "unknown error";
+    return Result.fail({
+        path,
+        message
+    });
+};
+export { parseAutomationSettingsIssue };
+
+//# sourceMappingURL=parseAutomationSettingsIssue.js.map

package/domain/automation/parseAutomationSettingsIssue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/automation/parseAutomationSettingsIssue.js","sources":["../../../src/domain/automation/parseAutomationSettingsIssue.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport type { ZodType } from \"zod\";\n\n/** The first problem of a step's automation settings (R267): where it is and what is wrong. */\nexport interface AutomationSettingsIssue {\n    /** The zod issue path joined by dots; empty when the issue has no path. */\n    path: string;\n    message: string;\n}\n\n/**\n * Parses a step's settings with the definition's `settingsSchema`, like `parseAutomationSettings`,\n * but fails with the first issue split into its path and message, so the save-time validation can\n * name the settings field (R267). Ok is the parsed value (defaults applied).\n */\nexport const parseAutomationSettingsIssue = (\n    schema: ZodType,\n    settings: unknown\n): Result<unknown, AutomationSettingsIssue> => {\n    const parsed = schema.safeParse(settings);\n    if (parsed.success) {\n        return Result.ok(parsed.data);\n    }\n    const [issue] = parsed.error.issues;\n    const path = issue?.path.map(String).join(\".\") ?? \"\";\n    const message = issue?.message ?? \"unknown error\";\n    return Result.fail({ path, message });\n};\n"],"names":["parseAutomationSettingsIssue","schema","settings","parsed","Result","issue","path","String","message"],"mappings":";AAeO,MAAMA,+BAA+B,CACxCC,QACAC;IAEA,MAAMC,SAASF,OAAO,SAAS,CAACC;IAChC,IAAIC,OAAO,OAAO,EACd,OAAOC,OAAO,EAAE,CAACD,OAAO,IAAI;IAEhC,MAAM,CAACE,MAAM,GAAGF,OAAO,KAAK,CAAC,MAAM;IACnC,MAAMG,OAAOD,OAAO,KAAK,IAAIE,QAAQ,KAAK,QAAQ;IAClD,MAAMC,UAAUH,OAAO,WAAW;IAClC,OAAOD,OAAO,IAAI,CAAC;QAAEE;QAAME;IAAQ;AACvC"}

package/domain/config/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A step type the workflow editor can offer (D130): a row of `listStepTypes`, built from the
+ * `StepType` registry (R138).
+ */
+export interface WorkflowStepTypeInfo {
+    /** Stored on `WorkflowStep.type`, e.g. "review". */
+    type: string;
+    title: string;
+    /** Whether a step of this type may be added now. */
+    available: boolean;
+    /** Why it is unavailable; `null` when available. */
+    unavailableReason: string | null;
+    /** JSON schema of the step's `config`; `null` when the type has no editable config yet. */
+    configSchema: Record<string, unknown> | null;
+}
+/**
+ * An automation a workflow author can add as a step (R138): a row of `listAutomationDefinitions`.
+ * `models` is the scope (D35); `settingsSchema` is the JSON schema of what the author fills in.
+ */
+export interface AutomationDefinitionInfo {
+    id: string;
+    name: string;
+    models: string[];
+    settingsSchema: Record<string, unknown>;
+}
+/**
+ * An AI tool a workflow author can allowlist on an AI step (R167): a row of `listAiTools`. No
+ * input schema: the editor shows what a tool is, the runner builds what the model sees.
+ */
+export interface WorkflowAiToolInfo {
+    name: string;
+    title: string;
+    description: string;
+    /** The plain name the step editor shows. */
+    label: string;
+    /** The one sentence the step editor shows. */
+    summary: string;
+    /** True when the tool writes or updates the content under review (R283). */
+    changesContent: boolean;
+}
+/**
+ * A user as the workflows configuration screens list one (D48, D104, R286): no email or roles.
+ * `teamIds` are the ids of the user's teams, never their names; `[]` for a user with no teams and
+ * for every user while teams are off.
+ */
+export interface WorkflowListedUser {
+    id: string;
+    displayName: string;
+    teamIds: string[];
+}
+/** The shared user list (R123). `missingIds`: requested ids with no user (D117); `[]` for a search. */
+export interface WorkflowUserList {
+    users: WorkflowListedUser[];
+    missingIds: string[];
+}
+/**
+ * A team as the workflow editor lists one (R268): no slug, description or roles. `memberCount` is
+ * the number of admin users in the team, so the editor can warn about a team with no members.
+ */
+export interface WorkflowTeamSummary {
+    id: string;
+    name: string;
+    memberCount: number;
+}
+/** The shared team list (R268). `missingIds`: requested ids with no team; `[]` for a search. */
+export interface WorkflowTeamList {
+    teams: WorkflowTeamSummary[];
+    missingIds: string[];
+}

package/domain/forEachWithConcurrency.d.ts

@@ -0,0 +1,15 @@
+/** Runs on one item; must not throw (a throw rejects the whole run). */
+export type ConcurrentItemTask<T> = (item: T) => Promise<void>;
+/**
+ * Runs `task` on every item, at most `limit` at a time, in no particular order: a fixed number of
+ * workers each takes the next item.
+ *
+ * An accepted exception to "no storage I/O in loops", only for independent writes that have no
+ * batch API and stay few. Its two uses:
+ * - `ReviewSaver`: the assignment records of a save (the CMS has no create-multiple). Usually one
+ *   to three; at most about the step's team size when nearly every candidate is skipped.
+ * - `DeleteTargetReviewsUseCase`: `CleanupTaskSubtreeUseCase` per run task of a deleted review
+ *   (it takes one task id). One to four per review; run tasks have no subtasks.
+ * Anything with a batch API, or that can grow with stored data, must batch instead.
+ */
+export declare const forEachWithConcurrency: <T>(items: T[], limit: number, task: ConcurrentItemTask<T>) => Promise<void>;

package/domain/forEachWithConcurrency.js

@@ -0,0 +1,17 @@
+const forEachWithConcurrency = async (items, limit, task)=>{
+    let next = 0;
+    const worker = async ()=>{
+        while(next < items.length){
+            const item = items[next];
+            next++;
+            await task(item);
+        }
+    };
+    const workerCount = Math.min(limit, items.length);
+    const workers = [];
+    for(let index = 0; index < workerCount; index++)workers.push(worker());
+    await Promise.all(workers);
+};
+export { forEachWithConcurrency };
+
+//# sourceMappingURL=forEachWithConcurrency.js.map

package/domain/forEachWithConcurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/forEachWithConcurrency.js","sources":["../../src/domain/forEachWithConcurrency.ts"],"sourcesContent":["/** Runs on one item; must not throw (a throw rejects the whole run). */\nexport type ConcurrentItemTask<T> = (item: T) => Promise<void>;\n\n/**\n * Runs `task` on every item, at most `limit` at a time, in no particular order: a fixed number of\n * workers each takes the next item.\n *\n * An accepted exception to \"no storage I/O in loops\", only for independent writes that have no\n * batch API and stay few. Its two uses:\n * - `ReviewSaver`: the assignment records of a save (the CMS has no create-multiple). Usually one\n *   to three; at most about the step's team size when nearly every candidate is skipped.\n * - `DeleteTargetReviewsUseCase`: `CleanupTaskSubtreeUseCase` per run task of a deleted review\n *   (it takes one task id). One to four per review; run tasks have no subtasks.\n * Anything with a batch API, or that can grow with stored data, must batch instead.\n */\nexport const forEachWithConcurrency = async <T>(\n    items: T[],\n    limit: number,\n    task: ConcurrentItemTask<T>\n): Promise<void> => {\n    let next = 0;\n    const worker = async (): Promise<void> => {\n        while (next < items.length) {\n            const item = items[next];\n            next++;\n            // oxlint-disable-next-line no-await-in-loop -- each worker runs its items one by one; the workers run in parallel.\n            await task(item);\n        }\n    };\n    const workerCount = Math.min(limit, items.length);\n    const workers: Promise<void>[] = [];\n    for (let index = 0; index < workerCount; index++) {\n        workers.push(worker());\n    }\n    await Promise.all(workers);\n};\n"],"names":["forEachWithConcurrency","items","limit","task","next","worker","item","workerCount","Math","workers","index","Promise"],"mappings":"AAeO,MAAMA,yBAAyB,OAClCC,OACAC,OACAC;IAEA,IAAIC,OAAO;IACX,MAAMC,SAAS;QACX,MAAOD,OAAOH,MAAM,MAAM,CAAE;YACxB,MAAMK,OAAOL,KAAK,CAACG,KAAK;YACxBA;YAEA,MAAMD,KAAKG;QACf;IACJ;IACA,MAAMC,cAAcC,KAAK,GAAG,CAACN,OAAOD,MAAM,MAAM;IAChD,MAAMQ,UAA2B,EAAE;IACnC,IAAK,IAAIC,QAAQ,GAAGA,QAAQH,aAAaG,QACrCD,QAAQ,IAAI,CAACJ;IAEjB,MAAMM,QAAQ,GAAG,CAACF;AACtB"}

package/domain/hasErrorSource.d.ts

@@ -0,0 +1,10 @@
+import type { PersistenceErrorSource } from "./PersistenceErrorSource.js";
+/**
+ * An error that keeps the raw storage error off its message and payload (R146). Server code logs
+ * `source`; clients only get the fixed message.
+ */
+export interface ErrorWithSource extends Error {
+    readonly source: PersistenceErrorSource;
+}
+/** Duck-typed so errors built in other packages are recognised. */
+export declare const hasErrorSource: (error: unknown) => error is ErrorWithSource;

package/domain/hasErrorSource.js

@@ -0,0 +1,4 @@
+const hasErrorSource = (error)=>error instanceof Error && error.source instanceof Error;
+export { hasErrorSource };
+
+//# sourceMappingURL=hasErrorSource.js.map

package/domain/hasErrorSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/hasErrorSource.js","sources":["../../src/domain/hasErrorSource.ts"],"sourcesContent":["import type { PersistenceErrorSource } from \"./PersistenceErrorSource.js\";\n\n/**\n * An error that keeps the raw storage error off its message and payload (R146). Server code logs\n * `source`; clients only get the fixed message.\n */\nexport interface ErrorWithSource extends Error {\n    readonly source: PersistenceErrorSource;\n}\n\n/** Duck-typed so errors built in other packages are recognised. */\nexport const hasErrorSource = (error: unknown): error is ErrorWithSource => {\n    return error instanceof Error && (error as Partial<ErrorWithSource>).source instanceof Error;\n};\n"],"names":["hasErrorSource","error","Error"],"mappings":"AAWO,MAAMA,iBAAiB,CAACC,QACpBA,iBAAiBC,SAAUD,MAAmC,MAAM,YAAYC"}

package/domain/notifications/clampComment.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The rejection comment as a message shows it (R189a): trimmed, and cut so that the result,
+ * including the appended `…`, is at most `NOTIFICATION_COMMENT_MAX_LENGTH` code points. Counted by
+ * code point, so an emoji is never split. Pure.
+ */
+export declare const clampComment: (comment: string) => string;

package/domain/notifications/clampComment.js

@@ -0,0 +1,11 @@
+import { NOTIFICATION_COMMENT_MAX_LENGTH } from "./constants.js";
+const clampComment = (comment)=>{
+    const trimmed = comment.trim();
+    const characters = Array.from(trimmed);
+    if (characters.length <= NOTIFICATION_COMMENT_MAX_LENGTH) return trimmed;
+    const kept = characters.slice(0, NOTIFICATION_COMMENT_MAX_LENGTH - 1).join("");
+    return `${kept.trimEnd()}…`;
+};
+export { clampComment };
+
+//# sourceMappingURL=clampComment.js.map

package/domain/notifications/clampComment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/notifications/clampComment.js","sources":["../../../src/domain/notifications/clampComment.ts"],"sourcesContent":["import { NOTIFICATION_COMMENT_MAX_LENGTH } from \"~/domain/notifications/constants.js\";\n\n/**\n * The rejection comment as a message shows it (R189a): trimmed, and cut so that the result,\n * including the appended `…`, is at most `NOTIFICATION_COMMENT_MAX_LENGTH` code points. Counted by\n * code point, so an emoji is never split. Pure.\n */\nexport const clampComment = (comment: string): string => {\n    const trimmed = comment.trim();\n    const characters = Array.from(trimmed);\n    if (characters.length <= NOTIFICATION_COMMENT_MAX_LENGTH) {\n        return trimmed;\n    }\n    const kept = characters.slice(0, NOTIFICATION_COMMENT_MAX_LENGTH - 1).join(\"\");\n    return `${kept.trimEnd()}…`;\n};\n"],"names":["clampComment","comment","trimmed","characters","Array","NOTIFICATION_COMMENT_MAX_LENGTH","kept"],"mappings":";AAOO,MAAMA,eAAe,CAACC;IACzB,MAAMC,UAAUD,QAAQ,IAAI;IAC5B,MAAME,aAAaC,MAAM,IAAI,CAACF;IAC9B,IAAIC,WAAW,MAAM,IAAIE,iCACrB,OAAOH;IAEX,MAAMI,OAAOH,WAAW,KAAK,CAAC,GAAGE,kCAAkC,GAAG,IAAI,CAAC;IAC3E,OAAO,GAAGC,KAAK,OAAO,GAAG,CAAC,CAAC;AAC/B"}

package/domain/notifications/constants.d.ts

@@ -0,0 +1,2 @@
+/** The rejection comment in a message is cut to this many characters, `…` included (R189a). */
+export declare const NOTIFICATION_COMMENT_MAX_LENGTH = 300;

package/domain/notifications/constants.js

@@ -0,0 +1,4 @@
+const NOTIFICATION_COMMENT_MAX_LENGTH = 300;
+export { NOTIFICATION_COMMENT_MAX_LENGTH };
+
+//# sourceMappingURL=constants.js.map

package/domain/notifications/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/notifications/constants.js","sources":["../../../src/domain/notifications/constants.ts"],"sourcesContent":["/** The rejection comment in a message is cut to this many characters, `…` included (R189a). */\nexport const NOTIFICATION_COMMENT_MAX_LENGTH = 300;\n"],"names":["NOTIFICATION_COMMENT_MAX_LENGTH"],"mappings":"AACO,MAAMA,kCAAkC"}

package/domain/notifications/dropActor.d.ts

@@ -0,0 +1,11 @@
+import type { Actor } from "../../domain/review/types.js";
+/** A notification recipient, known by its id. */
+export interface DropActorRecipient {
+    id: string;
+}
+/**
+ * Nobody is told about their own action (R184), but only a person's. An AI or an automation actor
+ * carries the requester's id (D58), so it never drops the requester: the requester still hears
+ * that the AI rejected the review. Returns a new array. Pure.
+ */
+export declare const dropActor: <T extends DropActorRecipient>(recipients: T[], actor: Actor) => T[];

package/domain/notifications/dropActor.js

@@ -0,0 +1,9 @@
+const dropActor = (recipients, actor)=>{
+    if ("user" !== actor.type) return [
+        ...recipients
+    ];
+    return recipients.filter((recipient)=>recipient.id !== actor.id);
+};
+export { dropActor };
+
+//# sourceMappingURL=dropActor.js.map

package/domain/notifications/dropActor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/notifications/dropActor.js","sources":["../../../src/domain/notifications/dropActor.ts"],"sourcesContent":["import type { Actor } from \"~/domain/review/types.js\";\n\n/** A notification recipient, known by its id. */\nexport interface DropActorRecipient {\n    id: string;\n}\n\n/**\n * Nobody is told about their own action (R184), but only a person's. An AI or an automation actor\n * carries the requester's id (D58), so it never drops the requester: the requester still hears\n * that the AI rejected the review. Returns a new array. Pure.\n */\nexport const dropActor = <T extends DropActorRecipient>(recipients: T[], actor: Actor): T[] => {\n    if (actor.type !== \"user\") {\n        return [...recipients];\n    }\n    return recipients.filter(recipient => recipient.id !== actor.id);\n};\n"],"names":["dropActor","recipients","actor","recipient"],"mappings":"AAYO,MAAMA,YAAY,CAA+BC,YAAiBC;IACrE,IAAIA,AAAe,WAAfA,MAAM,IAAI,EACV,OAAO;WAAID;KAAW;IAE1B,OAAOA,WAAW,MAAM,CAACE,CAAAA,YAAaA,UAAU,EAAE,KAAKD,MAAM,EAAE;AACnE"}

package/domain/notifications/getActorName.d.ts

@@ -0,0 +1,7 @@
+import type { Actor } from "../../domain/review/types.js";
+/**
+ * How a message names an actor (D107, D126, R189a): a person by their display name (a blank name
+ * reads "A user"), an AI step or an automation by the step title, never by the model's or the
+ * automation's own name. Pure.
+ */
+export declare const getActorName: (actor: Actor, stepTitle: string) => string;

package/domain/notifications/getActorName.js

@@ -0,0 +1,8 @@
+const getActorName = (actor, stepTitle)=>{
+    if ("user" !== actor.type) return stepTitle;
+    const name = actor.displayName.trim();
+    return "" === name ? "A user" : name;
+};
+export { getActorName };
+
+//# sourceMappingURL=getActorName.js.map

package/domain/notifications/getActorName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/notifications/getActorName.js","sources":["../../../src/domain/notifications/getActorName.ts"],"sourcesContent":["import type { Actor } from \"~/domain/review/types.js\";\n\n/**\n * How a message names an actor (D107, D126, R189a): a person by their display name (a blank name\n * reads \"A user\"), an AI step or an automation by the step title, never by the model's or the\n * automation's own name. Pure.\n */\nexport const getActorName = (actor: Actor, stepTitle: string): string => {\n    if (actor.type !== \"user\") {\n        return stepTitle;\n    }\n    const name = actor.displayName.trim();\n    return name === \"\" ? \"A user\" : name;\n};\n"],"names":["getActorName","actor","stepTitle","name"],"mappings":"AAOO,MAAMA,eAAe,CAACC,OAAcC;IACvC,IAAID,AAAe,WAAfA,MAAM,IAAI,EACV,OAAOC;IAEX,MAAMC,OAAOF,MAAM,WAAW,CAAC,IAAI;IACnC,OAAOE,AAAS,OAATA,OAAc,WAAWA;AACpC"}

package/domain/notifications/getReviewChangeRecipients.d.ts

@@ -0,0 +1,8 @@
+import type { Actor, ReviewData } from "../../domain/review/types.js";
+/**
+ * Who gets the silent `workflows.reviewChanged` message (R254): the requester and the current
+ * owner when that is a user, each once, minus the actor when the actor is a user (`dropActor`, the
+ * phase 7 rule). The actor's own tab refreshes through its own action. No pool lookup. An empty
+ * or missing id is never a recipient. Pure.
+ */
+export declare const getReviewChangeRecipients: (review: ReviewData, actor: Actor) => string[];

package/domain/notifications/getReviewChangeRecipients.js

@@ -0,0 +1,16 @@
+import { dropActor } from "./dropActor.js";
+const getReviewChangeRecipients = (review, actor)=>{
+    const ids = [];
+    for (const id of [
+        review.createdBy.id,
+        review.currentOwnerId
+    ])if ("string" == typeof id && "" !== id && !ids.includes(id)) ids.push(id);
+    const recipients = ids.map((id)=>({
+            id
+        }));
+    const remaining = dropActor(recipients, actor);
+    return remaining.map((item)=>item.id);
+};
+export { getReviewChangeRecipients };
+
+//# sourceMappingURL=getReviewChangeRecipients.js.map

package/domain/notifications/getReviewChangeRecipients.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/notifications/getReviewChangeRecipients.js","sources":["../../../src/domain/notifications/getReviewChangeRecipients.ts"],"sourcesContent":["import { dropActor } from \"~/domain/notifications/dropActor.js\";\nimport type { Actor, ReviewData } from \"~/domain/review/types.js\";\n\n/**\n * Who gets the silent `workflows.reviewChanged` message (R254): the requester and the current\n * owner when that is a user, each once, minus the actor when the actor is a user (`dropActor`, the\n * phase 7 rule). The actor's own tab refreshes through its own action. No pool lookup. An empty\n * or missing id is never a recipient. Pure.\n */\nexport const getReviewChangeRecipients = (review: ReviewData, actor: Actor): string[] => {\n    const ids: string[] = [];\n    for (const id of [review.createdBy.id, review.currentOwnerId]) {\n        if (typeof id === \"string\" && id !== \"\" && !ids.includes(id)) {\n            ids.push(id);\n        }\n    }\n\n    const recipients = ids.map(id => ({ id }));\n    const remaining = dropActor(recipients, actor);\n    return remaining.map(item => item.id);\n};\n"],"names":["getReviewChangeRecipients","review","actor","ids","id","recipients","remaining","dropActor","item"],"mappings":";AASO,MAAMA,4BAA4B,CAACC,QAAoBC;IAC1D,MAAMC,MAAgB,EAAE;IACxB,KAAK,MAAMC,MAAM;QAACH,OAAO,SAAS,CAAC,EAAE;QAAEA,OAAO,cAAc;KAAC,CACzD,IAAI,AAAc,YAAd,OAAOG,MAAmBA,AAAO,OAAPA,MAAa,CAACD,IAAI,QAAQ,CAACC,KACrDD,IAAI,IAAI,CAACC;IAIjB,MAAMC,aAAaF,IAAI,GAAG,CAACC,CAAAA,KAAO;YAAEA;QAAG;IACvC,MAAME,YAAYC,UAAUF,YAAYH;IACxC,OAAOI,UAAU,GAAG,CAACE,CAAAA,OAAQA,KAAK,EAAE;AACxC"}