AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents
TypeScript ai-agentai-agent-toolsai-agentsai-agents-frameworkmcpmcp-servermcp-toolsmcpsn8n-alternativeno-code-automationworkflowworkflow-automationworkflows
feat(builder): ask for required actions before publishing (#15954)
Abduldcebeca5ba18
diff --git a/packages/web/public/locales/en/translation.json b/packages/web/public/locales/en/translation.jsonindex bd41c0de91f..884b733c891 100644--- a/packages/web/public/locales/en/translation.json+++ b/packages/web/public/locales/en/translation.json@@ -1,4 +1,6 @@{+ "You must include these actions to publish.": "You must include these actions to publish.",+ "You must include one of these actions to publish.": "You must include one of these actions to publish.","At least one": "At least one","No required actions": "No required actions","Choose actions that flows in projects assigned to this set must include before they can publish.": "Choose actions that flows in projects assigned to this set must include before they can publish.",diff --git a/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx b/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsxindex 0954f881a45..1d08c6ec741 100644--- a/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx+++ b/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx@@ -8,6 +8,7 @@ import {import { useMutation } from '@tanstack/react-query';import { t } from 'i18next';import { Info } from 'lucide-react';+import { useState } from 'react';import { RightSideBarType } from '@/app/builder/types';import { LoadingSpinner } from '@/components/custom/spinner';@@ -26,6 +27,11 @@ import { useBuilderStateContext } from '../../builder-hooks';import { runDiscard } from './discard-draft';import LargeWidgetWrapper from './large-widget-wrapper';+import {+ FailedRequiredActionsCheck,+ RequiredActionsDialog,+ useRequiredActionsCheck,+} from './required-actions-dialog';const PublishFlowReminderWidget = () => {const [@@ -79,6 +85,10 @@ const PublishFlowReminderWidget = () => {}),},);+ const { checkRequiredActions, explainServerRejection } =+ useRequiredActionsCheck();+ const [failedRequiredActionsCheck, setFailedRequiredActionsCheck] =+ useState<FailedRequiredActionsCheck | null>(null);const { mutateAsync: publish } = flowHooks.useChangeFlowStatus({flowId: flow.id,change: 'publish',@@ -87,7 +97,22 @@ const PublishFlowReminderWidget = () => {setVersion(updatedFlow.version);},setIsPublishing: setIsPublishing,+ onRequiredActionsMissing: (params) => {+ explainServerRejection(params)+ .then(setFailedRequiredActionsCheck)+ .catch(() => undefined);+ },});+ const handlePublish = async () => {+ setIsPublishing(true);+ const failedCheck = await checkRequiredActions(flowVersion);+ if (failedCheck) {+ setIsPublishing(false);+ setFailedRequiredActionsCheck(failedCheck);+ return;+ }+ await publish();+ };const { mutateAsync: overWriteDraftWithVersion } =flowHooks.useOverWriteDraftWithVersion({onSuccess: (updatedFlow) => {@@ -136,7 +161,7 @@ const PublishFlowReminderWidget = () => {loading={isSaving}//for e2e testsname="Publish"- onClick={() => publish()}+ onClick={handlePublish}disabled={!isValid}>{requiresApproval ? t('Request approval') : t('Publish')}@@ -150,6 +175,10 @@ const PublishFlowReminderWidget = () => {</Tooltip></div>)}+ <RequiredActionsDialog+ failedCheck={failedRequiredActionsCheck}+ onClose={() => setFailedRequiredActionsCheck(null)}+ /></LargeWidgetWrapper>);};diff --git a/packages/web/src/app/builder/flow-canvas/widgets/required-actions-dialog.tsx b/packages/web/src/app/builder/flow-canvas/widgets/required-actions-dialog.tsxnew file mode 100644index 00000000000..4a6729e0ec7--- /dev/null+++ b/packages/web/src/app/builder/flow-canvas/widgets/required-actions-dialog.tsx@@ -0,0 +1,521 @@+import {+ isNil,+ RequiredActionsMissingErrorParams,+ tryCatch,+ unique,+} from '@activepieces/core-utils';+import { PieceMetadataModel } from '@activepieces/pieces-framework';+import {+ FlowActionType,+ FlowOperationType,+ FlowVersion,+ RequiredActionsCheckResult,+ RequiredActionsMode,+ requiredActionsUtil,+ StepLocationRelativeToParent,+} from '@activepieces/shared';+import { QueryClient, useQueryClient } from '@tanstack/react-query';+import { useReactFlow } from '@xyflow/react';+import { t } from 'i18next';+import { useState } from 'react';+import { useTranslation } from 'react-i18next';++import {+ BuilderState,+ useBuilderStateContext,+} from '@/app/builder/builder-hooks';+import { getLastLocationAsPasteLocation } from '@/app/builder/flow-canvas/utils/bulk-actions';+import { flowCanvasUtils } from '@/app/builder/flow-canvas/utils/flow-canvas-utils';+import { Badge } from '@/components/ui/badge';+import { Button } from '@/components/ui/button';+import { Checkbox } from '@/components/ui/checkbox';+import {+ Dialog,+ DialogContent,+ DialogDescription,+ DialogFooter,+ DialogHeader,+ DialogTitle,+} from '@/components/ui/dialog';+import { ScrollArea } from '@/components/ui/scroll-area';+import {+ pieceSetQueryOptions,+ RequiredActionGroupHeader,+} from '@/features/piece-sets';+import { pieceQueryOptions, stepUtils } from '@/features/pieces';+import { projectCollectionUtils } from '@/features/projects';+import { platformHooks } from '@/hooks/platform-hooks';+import { cn } from '@/lib/utils';++export function useRequiredActionsCheck() {+ const queryClient = useQueryClient();+ const { i18n } = useTranslation();+ const { platform } = platformHooks.useCurrentPlatform();+ const { project } = projectCollectionUtils.useCurrentProject();++ const checkRequiredActions = async (+ flowVersion: FlowVersion,+ ): Promise<FailedRequiredActionsCheck | null> => {+ if (!platform.plan.managePiecesEnabled) {+ return null;+ }+ const { data } = await tryCatch(() =>+ loadAndCheckRequiredActions({+ queryClient,+ projectId: project.id,+ language: i18n.language,+ flowVersion,+ }),+ );+ return data ?? null;+ };++ const explainServerRejection = async (+ params: RequiredActionsMissingErrorParams['params'],+ ): Promise<FailedRequiredActionsCheck> => {+ const result = toCheckResult(params);+ const pieceNames = unique([+ ...Object.keys(result.missingActions),+ ...Object.keys(result.skippedActions),+ ]);+ const piecesByName = await loadPiecesByName({+ queryClient,+ pieceNames,+ language: i18n.language,+ });+ return { result, piecesByName };+ };++ return { checkRequiredActions, explainServerRejection };+}++export function RequiredActionsDialog({+ failedCheck,+ onClose,+}: {+ failedCheck: FailedRequiredActionsCheck | null;+ onClose: () => void;+}) {+ return (+ <Dialog+ open={failedCheck !== null}+ onOpenChange={(open) => !open && onClose()}+ >+ <DialogContent className="sm:max-w-md">+ {failedCheck && (+ <RequiredActionsDialogContent+ failedCheck={failedCheck}+ onClose={onClose}+ />+ )}+ </DialogContent>+ </Dialog>+ );+}++function RequiredActionsDialogContent({+ failedCheck,+ onClose,+}: {+ failedCheck: FailedRequiredActionsCheck;+ onClose: () => void;+}) {+ const { result, piecesByName } = failedCheck;+ const { fitView } = useReactFlow();+ const [flowVersion, handleAddingOrUpdatingStep] = useBuilderStateContext(+ (state) => [state.flowVersion, state.handleAddingOrUpdatingStep],+ );+ const areAllActionsRequired = result.mode === RequiredActionsMode.ALL;+ const missingRequiredActionsGroupedByPiece = buildMissingRequiredActionGroups(+ {+ result,+ piecesByName,+ },+ );+ const missingRequiredActions = missingRequiredActionsGroupedByPiece.flatMap(+ (group) => group.actions,+ );+ const [requiredActionsToAdd, setRequiredActionsToAdd] = useState<+ Record<string, string[]>+ >(() =>+ groupByPiece(+ areAllActionsRequired+ ? missingRequiredActions+ : missingRequiredActions.slice(0, 1),+ ),+ );+ const missingRequiredActionsToAdd = missingRequiredActions.filter((action) =>+ willBeAdded({ requiredActionsToAdd, action }),+ );++ const toggleRequiredActionToAdd = (action: MissingRequiredAction) =>+ setRequiredActionsToAdd((prev) =>+ toggleRequiredAction({ requiredActionsToAdd: prev, action }),+ );++ const [showNoActionError, setShowNoActionError] = useState(false);++ const addSteps = () => {+ if (missingRequiredActionsToAdd.length === 0) {+ setShowNoActionError(true);+ return;+ }+ const addedStepNames = addRequiredSteps({+ requiredActions: missingRequiredActionsToAdd,+ piecesByName,+ firstParentStepName:+ getLastLocationAsPasteLocation(flowVersion).parentStepName,+ addStep: handleAddingOrUpdatingStep,+ });+ const firstAddedStepName = addedStepNames[0];+ if (firstAddedStepName) {+ setTimeout(() =>+ fitView(+ flowCanvasUtils.createFocusStepInGraphParams(firstAddedStepName),+ ),+ );+ }+ onClose();+ };++ return (+ <>+ <DialogHeader>+ <DialogTitle>+ {areAllActionsRequired+ ? t('Add required actions')+ : t('Add a required action')}+ </DialogTitle>+ <DialogDescription>+ {areAllActionsRequired+ ? t('You must include these actions to publish.')+ : t('You must include one of these actions to publish.')}+ </DialogDescription>+ </DialogHeader>+ <ScrollArea viewPortClassName="max-h-96">+ <div className="flex flex-col gap-3">+ {missingRequiredActionsGroupedByPiece.map((group) => (+ <div key={group.pieceName} className="flex flex-col">+ <RequiredActionGroupHeader+ displayName={group.displayName}+ logoUrl={group.logoUrl}+ />+ {group.actions.map((action) =>+ areAllActionsRequired ? (+ <RequiredActionRow key={action.actionName} action={action} />+ ) : (+ <SelectableRequiredActionRow+ key={action.actionName}+ action={action}+ checked={willBeAdded({ requiredActionsToAdd, action })}+ onToggle={() => toggleRequiredActionToAdd(action)}+ />+ ),+ )}+ </div>+ ))}+ </div>+ </ScrollArea>+ {showNoActionError && missingRequiredActionsToAdd.length === 0 && (+ <p className="text-sm font-medium text-danger-11">+ {t('Select at least one action to add.')}+ </p>+ )}+ <DialogFooter>+ <Button type="button" variant="outline" onClick={onClose}>+ {t('Cancel')}+ </Button>+ <Button type="button" onClick={addSteps}>+ {t('addActionsCount', { count: missingRequiredActionsToAdd.length })}+ </Button>+ </DialogFooter>+ </>+ );+}++async function loadAndCheckRequiredActions({+ queryClient,+ projectId,+ language,+ flowVersion,+}: {+ queryClient: QueryClient;+ projectId: string;+ language: string;+ flowVersion: FlowVersion;+}): Promise<FailedRequiredActionsCheck | null> {+ const pieceSet = await queryClient.fetchQuery(+ pieceSetQueryOptions.project(projectId),+ );+ const { requiredActions } = pieceSet.config;+ const pieceNames = Object.keys(requiredActions.actions);+ if (pieceNames.length === 0) {+ return null;+ }+ const piecesByName = await loadPiecesByName({+ queryClient,+ pieceNames,+ language,+ });+ const actionExists = buildActionExistence({+ requiredActions: requiredActions.actions,+ piecesByName,+ });+ const result = requiredActionsUtil.checkRequiredActionsExistInFlowVersion({+ requiredActions,+ flowVersion,+ actionExists,+ });+ return result.passed ? null : { result, piecesByName };+}++async function loadPiecesByName({+ queryClient,+ pieceNames,+ language,+}: {+ queryClient: QueryClient;+ pieceNames: string[];+ language: string;+}): Promise<Map<string, PieceMetadataModel>> {+ const loadedPieces = await Promise.all(+ pieceNames.map((name) => loadLatestPiece({ queryClient, name, language })),+ );+ const pieces = loadedPieces.filter((piece) => !isNil(piece));+ return new Map(pieces.map((piece) => [piece.name, piece]));+}++function toCheckResult(+ params: RequiredActionsMissingErrorParams['params'],+): RequiredActionsCheckResult {+ const mode =+ params.mode === RequiredActionsMode.ALL+ ? RequiredActionsMode.ALL+ : RequiredActionsMode.ANY;+ return {+ passed: false,+ mode,+ requiredActions: params.requiredActions,+ missingActions: params.missingActions,+ skippedActions: params.skippedActions,+ };+}++async function loadLatestPiece({+ queryClient,+ name,+ language,+}: {+ queryClient: QueryClient;+ name: string;+ language: string;+}): Promise<PieceMetadataModel | undefined> {+ const { data } = await tryCatch(() =>+ queryClient.ensureQueryData(pieceQueryOptions.latest({ name, language })),+ );+ return data ?? undefined;+}++function buildActionExistence({+ requiredActions,+ piecesByName,+}: {+ requiredActions: Record<string, string[]>;+ piecesByName: Map<string, PieceMetadataModel>;+}): Record<string, Record<string, boolean>> {+ const existencePerPiece = Object.entries(requiredActions).map(+ ([pieceName, actionNames]) => {+ const piece = piecesByName.get(pieceName);+ const existencePerAction = actionNames.map((actionName) => [+ actionName,+ !isNil(piece?.actions[actionName]),+ ]);+ return [pieceName, Object.fromEntries(existencePerAction)];+ },+ );+ return Object.fromEntries(existencePerPiece);+}++function RequiredActionRow({ action }: { action: MissingRequiredAction }) {+ return (+ <div className="flex min-h-10 items-center gap-3 py-1.5 pl-9">+ <RequiredActionName action={action} />+ </div>+ );+}++function SelectableRequiredActionRow({+ action,+ checked,+ onToggle,+}: {+ action: MissingRequiredAction;+ checked: boolean;+ onToggle: () => void;+}) {+ return (+ <label className="flex min-h-10 cursor-pointer items-center gap-3 py-1.5 pl-1">+ <Checkbox checked={checked} onCheckedChange={onToggle} />+ <RequiredActionName action={action} className="pl-2" />+ </label>+ );+}++function RequiredActionName({+ action,+ className,+}: {+ action: MissingRequiredAction;+ className?: string;+}) {+ return (+ <>+ <span className={cn('flex-1 text-sm', className)}>+ {action.displayName}+ </span>+ {action.skipped && (+ <Badge variant="outline" className="shrink-0">+ {t('Skipped')}+ </Badge>+ )}+ </>+ );+}++function buildMissingRequiredActionGroups({+ result,+ piecesByName,+}: {+ result: RequiredActionsCheckResult;+ piecesByName: Map<string, PieceMetadataModel>;+}): MissingRequiredActionGroup[] {+ const pieceNames = unique([+ ...Object.keys(result.missingActions),+ ...Object.keys(result.skippedActions),+ ]);+ return pieceNames.map((pieceName) => {+ const piece = piecesByName.get(pieceName);+ const skippedActionNames = result.skippedActions[pieceName] ?? [];+ const actionNames = [+ ...(result.missingActions[pieceName] ?? []),+ ...skippedActionNames,+ ];+ return {+ pieceName,+ displayName: piece?.displayName ?? pieceName,+ logoUrl: piece?.logoUrl,+ actions: actionNames.map((actionName) => ({+ pieceName,+ actionName,+ displayName: piece?.actions[actionName]?.displayName ?? actionName,+ skipped: skippedActionNames.includes(actionName),+ })),+ };+ });+}++function groupByPiece(+ actions: MissingRequiredAction[],+): Record<string, string[]> {+ return actions.reduce<Record<string, string[]>>(+ (actionsByPiece, action) => ({+ ...actionsByPiece,+ [action.pieceName]: [+ ...(actionsByPiece[action.pieceName] ?? []),+ action.actionName,+ ],+ }),+ {},+ );+}++function willBeAdded({+ requiredActionsToAdd,+ action,+}: {+ requiredActionsToAdd: Record<string, string[]>;+ action: MissingRequiredAction;+}): boolean {+ return (+ requiredActionsToAdd[action.pieceName]?.includes(action.actionName) ?? false+ );+}++function toggleRequiredAction({+ requiredActionsToAdd,+ action,+}: {+ requiredActionsToAdd: Record<string, string[]>;+ action: MissingRequiredAction;+}): Record<string, string[]> {+ const actionNamesInPiece = requiredActionsToAdd[action.pieceName] ?? [];+ if (!willBeAdded({ requiredActionsToAdd, action })) {+ return {+ ...requiredActionsToAdd,+ [action.pieceName]: [...actionNamesInPiece, action.actionName],+ };+ }+ return {+ ...requiredActionsToAdd,+ [action.pieceName]: actionNamesInPiece.filter(+ (actionName) => actionName !== action.actionName,+ ),+ };+}++function addRequiredSteps({+ requiredActions,+ piecesByName,+ firstParentStepName,+ addStep,+}: {+ requiredActions: MissingRequiredAction[];+ piecesByName: Map<string, PieceMetadataModel>;+ firstParentStepName: string;+ addStep: BuilderState['handleAddingOrUpdatingStep'];+}): string[] {+ const addedStepNames: string[] = [];+ for (const requiredAction of requiredActions) {+ const piece = piecesByName.get(requiredAction.pieceName);+ const action = piece?.actions[requiredAction.actionName];+ if (!piece || !action) {+ continue;+ }+ const stepName = addStep({+ pieceSelectorItem: {+ actionOrTrigger: action,+ type: FlowActionType.PIECE,+ pieceMetadata: stepUtils.mapPieceToMetadata({ piece, type: 'action' }),+ },+ operation: {+ type: FlowOperationType.ADD_ACTION,+ actionLocation: {+ parentStep: addedStepNames.at(-1) ?? firstParentStepName,+ stepLocationRelativeToParent: StepLocationRelativeToParent.AFTER,+ },+ },+ selectStepAfter: addedStepNames.length === 0,+ });+ addedStepNames.push(stepName);+ }+ return addedStepNames;+}++export type FailedRequiredActionsCheck = {+ result: RequiredActionsCheckResult;+ piecesByName: Map<string, PieceMetadataModel>;+};++type MissingRequiredAction = {+ pieceName: string;+ actionName: string;+ displayName: string;+ skipped: boolean;+};++type MissingRequiredActionGroup = {+ pieceName: string;+ displayName: string;+ logoUrl: string | undefined;+ actions: MissingRequiredAction[];+};diff --git a/packages/web/src/app/components/project-settings/pieces/index.tsx b/packages/web/src/app/components/project-settings/pieces/index.tsxindex 2e28f8caf89..91e84d26a90 100644--- a/packages/web/src/app/components/project-settings/pieces/index.tsx+++ b/packages/web/src/app/components/project-settings/pieces/index.tsx@@ -87,9 +87,7 @@ const PiecesSettings = () => {isTableQuery: true,});- const { data: pieceSet } = pieceSetQueries.usePieceSet(- project.pieceSetId ?? '',- );+ const { data: pieceSet } = pieceSetQueries.useProjectPieceSet(project.id);const customFilters = useMemo(() => [diff --git a/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsx b/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsxindex 098b569d50c..b96f488a601 100644--- a/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsx+++ b/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsx@@ -13,7 +13,6 @@ import { VirtualizedList } from '@/components/ui/virtualized-list';import { RequestTrial } from '@/features/billing';import { pieceSetQueries } from '@/features/piece-sets';import { piecesHooks } from '@/features/pieces/hooks/pieces-hooks';-import { projectCollectionUtils } from '@/features/projects';import { useIsPlatformAdmin } from '@/hooks/authorization-hooks';import { platformHooks } from '@/hooks/platform-hooks';@@ -184,10 +183,7 @@ function RunActionDisabledAlert({function PieceSetBanner({ projectId }: { projectId: string | null }) {const { platform } = platformHooks.useCurrentPlatform();const isPlatformAdmin = useIsPlatformAdmin();- const { data: projects = [] } = projectCollectionUtils.useAll();- const pieceSetId =- projects.find((project) => project.id === projectId)?.pieceSetId ?? null;- const { data: pieceSet } = pieceSetQueries.usePieceSet(pieceSetId ?? '');+ const { data: pieceSet } = pieceSetQueries.useProjectPieceSet(projectId);if (!platform.plan.managePiecesEnabled) {return (@@ -225,8 +221,8 @@ function PieceSetBanner({ projectId }: { projectId: string | null }) {><Linkto={- pieceSetId- ? `/platform/pieces/piece-sets/${pieceSetId}`+ pieceSet+ ? `/platform/pieces/piece-sets/${pieceSet.id}`: PIECE_SETS_LIST_ROUTE}>diff --git a/packages/web/src/features/flows/hooks/flow-hooks.tsx b/packages/web/src/features/flows/hooks/flow-hooks.tsxindex 04fd72e32a4..a5ad4e86ace 100644--- a/packages/web/src/features/flows/hooks/flow-hooks.tsx+++ b/packages/web/src/features/flows/hooks/flow-hooks.tsx@@ -2,6 +2,7 @@ import {ApErrorParams,isNil,ErrorCode,+ RequiredActionsMissingErrorParams,SeekPage,} from '@activepieces/core-utils';import {@@ -72,6 +73,7 @@ export const flowHooks = {change,onSuccess,setIsPublishing,+ onRequiredActionsMissing,}: UseChangeFlowStatusParams) => {const { data: enableFlowOnPublish } = flagsHooks.useFlag<boolean>(ApFlagId.ENABLE_FLOW_ON_PUBLISH,@@ -169,6 +171,15 @@ export const flowHooks = {},technicalDetailsDefaultOpen: isNil(reportedError),});+ } else if (apError.code === ErrorCode.REQUIRED_ACTIONS_MISSING) {+ if (onRequiredActionsMissing) {+ onRequiredActionsMissing(apError.params);+ return;+ }+ toast.error(t('Publish failed'), {+ description: apError.params.message,+ duration: 5000,+ });} else if (apError.code === ErrorCode.QUOTA_EXCEEDED) {toast.error(t('Active flows limit reached'), {description: t(@@ -595,4 +606,7 @@ type UseChangeFlowStatusParams = {change: 'publish' | FlowStatus;onSuccess: (flow: PopulatedFlow) => void;setIsPublishing?: (isPublishing: boolean) => void;+ onRequiredActionsMissing?: (+ params: RequiredActionsMissingErrorParams['params'],+ ) => void;};