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
import { LocalesEnum, isNil } from '@activepieces/core-utils';
import { PieceMetadataModel } from '@activepieces/pieces-framework';
import {
FlowAction,
FlowActionType,
FlowTrigger,
FlowTriggerType,
flowStructureUtil,
PieceAudienceFilter,
} from '@activepieces/shared';
import { useQueries } from '@tanstack/react-query';
import { t } from 'i18next';
import { Database, SearchXIcon, Variable } from 'lucide-react';
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';
import { useDebounce } from 'use-debounce';
import { textMentionUtils } from '@/app/builder/piece-properties/text-input-with-mentions/text-input-utils';
import { SearchInput } from '@/components/custom/search-input';
import { OutputSchema } from '@/components/custom/smart-output-viewer/types';
import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
import { VirtualizedList } from '@/components/ui/virtualized-list';
import { pieceQueryKey, piecesApi } from '@/features/pieces';
import { cn } from '@/lib/utils';
import { ScrollArea } from '../../../components/ui/scroll-area';
import { BuilderState, useBuilderStateContext } from '../builder-hooks';
import { DataSelectorNode } from './data-selector-node';
import {
DataSelectorSizeState,
DataSelectorSizeTogglers,
} from './data-selector-size-togglers';
import { pathHelpers } from './path-helpers';
import { DataSelectorTreeNode } from './type';
import { dataSelectorUtils } from './utils';
import { schemaTreeUtils } from './utils-schema';
import { VariablesTab } from './variables-tab';
type StepInfo = (FlowAction | FlowTrigger) & { dfsIndex: number };
function getStepsAndData(state: BuilderState): {
steps: StepInfo[];
sampleData: Record<string, unknown>;
isFocusInsideListMapperModeInput: boolean;
} {
const { selectedStep, flowVersion } = state;
if (!selectedStep || !flowVersion || !flowVersion.trigger) {
return {
steps: [],
sampleData: {},
isFocusInsideListMapperModeInput: false,
};
}
const pathToTargetStep = flowStructureUtil.findPathToStep(
flowVersion.trigger,
selectedStep,
);
return {
steps: pathToTargetStep,
sampleData: state.outputSampleData,
isFocusInsideListMapperModeInput: state.isFocusInsideListMapperModeInput,
};
}
function buildAdvancedStructure(
steps: StepInfo[],
sampleData: Record<string, unknown>,
isFocusInsideListMapperModeInput: boolean,
targetStepName: string,
): DataSelectorTreeNode[] {
return steps.map((step) =>
traverseStepOrErrorNode({
step,
sampleData,
zipArraysOfProperties: isFocusInsideListMapperModeInput,
targetStepName,
}),
);
}
function traverseStepOrErrorNode({
step,
sampleData,
zipArraysOfProperties,
targetStepName,
}: {
step: StepInfo;
sampleData: Record<string, unknown>;
zipArraysOfProperties: boolean;
targetStepName: string;
}): DataSelectorTreeNode {
try {
return dataSelectorUtils.traverseStep(
step,
sampleData,
zipArraysOfProperties,
targetStepName,
);
} catch {
return {
key: `error-${step.name}`,
data: {
type: 'chunk' as const,
displayName: `Error loading ${step.name}`,
},
};
}
}
type DataSelectorProps = {
parentHeight: number;
parentWidth: number;
};
const doesElementHaveAnInputThatUsesMentions = (
element: Element | null,
): boolean => {
if (isNil(element)) {
return false;
}
if (element.classList.contains(textMentionUtils.inputWithMentionsCssClass)) {
return true;
}
const parent = element.parentElement;
if (parent) {
return doesElementHaveAnInputThatUsesMentions(parent);
}
return false;
};
const DataSelector = ({ parentHeight, parentWidth }: DataSelectorProps) => {
const containerRef = useRef<HTMLDivElement>(null);
const { i18n } = useTranslation();
const [dataSelectorSize, setDataSelectorSize] =
useState<DataSelectorSizeState>(DataSelectorSizeState.DOCKED);
const [searchTerm, setSearchTerm] = useState('');
const [viewMode, setViewMode] = useState<'friendly' | 'advanced'>('friendly');
const [showDataSelector, setShowDataSelector] = useState(false);
const { steps, sampleData, isFocusInsideListMapperModeInput } =
useBuilderStateContext(getStepsAndData);
const isTriggerSelected = useBuilderStateContext(
(state) => state.selectedStep === 'trigger',
);
const selectedStepName = useBuilderStateContext(
(state) => state.selectedStep ?? '',
);
const defaultTab = isTriggerSelected ? 'variables' : 'data';
const piecePairs = useMemo(
() =>
steps
.map((step) => {
if (step.type === FlowActionType.PIECE) {
return {
stepName: step.name,
pieceName: step.settings.pieceName,
pieceVersion: step.settings.pieceVersion,
stepKey: step.settings.actionName,
};
}
if (step.type === FlowTriggerType.PIECE) {
return {
stepName: step.name,
pieceName: step.settings.pieceName,
pieceVersion: step.settings.pieceVersion,
stepKey: step.settings.triggerName,
};
}
return null;
})
.filter(
(
entry,
): entry is {
stepName: string;
pieceName: string;
pieceVersion: string;
stepKey: string;
} =>
entry !== null &&
Boolean(entry.pieceName) &&
Boolean(entry.stepKey),
),
[steps],
);
const pieceQueries = useQueries({
queries: piecePairs.map(({ pieceName, pieceVersion }) => ({
queryKey: pieceQueryKey({
name: pieceName,
version: pieceVersion,
locale: i18n.language,
audience: PieceAudienceFilter.ALL,
}),
queryFn: () =>
piecesApi.get({
name: pieceName,
version: pieceVersion,
locale: i18n.language as LocalesEnum,
audience: PieceAudienceFilter.ALL,
}),
staleTime: Infinity,
})),
});
const schemaMap = useMemo<Record<string, OutputSchema | null>>(() => {
const result: Record<string, OutputSchema | null> = {};
piecePairs.forEach(({ stepName, stepKey }, idx) => {
const piece = pieceQueries[idx]?.data as PieceMetadataModel | undefined;
result[stepName] =
piece?.triggers?.[stepKey]?.outputSchema ??
piece?.actions?.[stepKey]?.outputSchema ??
null;
});
return result;
}, [piecePairs, pieceQueries]);
const advancedStructure = useMemo(
() =>
buildAdvancedStructure(
steps,
sampleData,
isFocusInsideListMapperModeInput,
selectedStepName,
),
[steps, sampleData, isFocusInsideListMapperModeInput, selectedStepName],
);
const friendlyStructure = useMemo(
() =>
steps.map((step) => {
const displayName = `${step.dfsIndex + 1}. ${step.displayName}`;
const stepData = sampleData[step.name];
if (
dataSelectorUtils.shouldShowStepAsFlatList({
isFocusInsideListMapperModeInput,
stepOutput: stepData,
})
) {
return traverseStepOrErrorNode({
step,
sampleData,
zipArraysOfProperties: true,
targetStepName: selectedStepName,
});
}
if (
typeof stepData === 'string' ||
typeof stepData === 'number' ||
typeof stepData === 'boolean'
) {
return {
key: step.name,
data: {
type: 'value' as const,
value: '',
displayName,
propertyPath: pathHelpers.propertyPathStarter(step.name),
insertable: true,
stepName: step.name,
},
children: [
{
key: `${step.name}_value`,
data: {
type: 'value' as const,
value: stepData,
displayName: t('Result'),
propertyPath: pathHelpers.propertyPathStarter(step.name),
insertable: true,
},
},
],
};
}
const schema = schemaMap[step.name];
if (Array.isArray(stepData) && stepData.length > 0) {
const arrayKind = schemaTreeUtils.selectArrayTreeKind(schema);
// A whole-output wrapper schema (single value:'' field) names the
// array itself — render it object-style so the wrapper field sits at
// the top with rows beneath, instead of wrapping each row in Item N.
if (schema && arrayKind === 'wrapper') {
return schemaTreeUtils.buildTreeFromSchema({
stepName: step.name,
displayName,
schema,
sampleData: stepData,
});
}
if (schema && arrayKind === 'perItem') {
return schemaTreeUtils.buildTreeFromArrayWithSchema({
stepName: step.name,
displayName,
schema,
items: stepData,
});
}
return schemaTreeUtils.buildTreeFromArray({
stepName: step.name,
displayName,
items: stepData,
});
}
if (schema) {
return schemaTreeUtils.buildTreeFromSchema({
stepName: step.name,
displayName,
schema,
sampleData: stepData,
});
}
return traverseStepOrErrorNode({
step,
sampleData,
zipArraysOfProperties: false,
targetStepName: selectedStepName,
});
}),
[
steps,
sampleData,
schemaMap,
isFocusInsideListMapperModeInput,
selectedStepName,
],
);
const currentStructure =
viewMode === 'friendly' ? friendlyStructure : advancedStructure;
const [debouncedSearchTerm] = useDebounce(searchTerm, 250);
const filteredNodes = useMemo(
() => dataSelectorUtils.filterBy(currentStructure, debouncedSearchTerm),
[currentStructure, debouncedSearchTerm],
);
const expansionScope = `${viewMode}|${debouncedSearchTerm}`;
const [expansion, setExpansion] = useState<ExpansionState>({
scope: '',
overrides: EMPTY_OVERRIDES,
});
const overrides =
expansion.scope === expansionScope ? expansion.overrides : EMPTY_OVERRIDES;
const rows = useMemo(
() =>
dataSelectorUtils.flattenVisibleRows({
nodes: filteredNodes,
searchActive: debouncedSearchTerm.length > 0,
overrides,
}),
[filteredNodes, debouncedSearchTerm, overrides],
);
const setRowExpanded = useCallback(
(rowId: string, expanded: boolean) => {
setExpansion((current) => ({
scope: expansionScope,
overrides: new Map(
current.scope === expansionScope
? current.overrides
: EMPTY_OVERRIDES,
).set(rowId, expanded),
}));
},
[expansionScope],
);
const checkFocus = useCallback(() => {
const isTextMentionInputFocused =
(!isNil(containerRef.current) &&
containerRef.current.contains(document.activeElement)) ||
doesElementHaveAnInputThatUsesMentions(document.activeElement);
setShowDataSelector(isTextMentionInputFocused);
}, []);
useEffect(() => {
document.addEventListener('focusin', checkFocus);
document.addEventListener('focusout', checkFocus);
return () => {
document.removeEventListener('focusin', checkFocus);
document.removeEventListener('focusout', checkFocus);
};
}, [checkFocus]);
return (
<div
ref={containerRef}
tabIndex={0}
className={cn(
'absolute bottom-0 mr-5 mb-5 right-0 z-50 transition-all border border-solid overflow-x-hidden bg-gray-1 shadow-lg rounded-md',
{
'opacity-0 pointer-events-none': !showDataSelector,
},
textMentionUtils.dataSelectorCssClassSelector,
)}
>
<div className="text-lg items-center px-3 py-2 flex gap-2">
{t('Data Selector')} <div className="grow"></div>{' '}
<DataSelectorSizeTogglers
state={dataSelectorSize}
setListSizeState={setDataSelectorSize}
></DataSelectorSizeTogglers>
</div>
<div
style={{
height:
dataSelectorSize === DataSelectorSizeState.COLLAPSED
? '0px'
: dataSelectorSize === DataSelectorSizeState.DOCKED
? '450px'
: `${parentHeight - 100}px`,
width:
dataSelectorSize !== DataSelectorSizeState.EXPANDED
? '450px'
: `${parentWidth - 40}px`,
}}
className="transition-all overflow-hidden"
>
<Tabs
key={defaultTab}
defaultValue={defaultTab}
className="h-full flex flex-col gap-0"
>
<TabsList
variant="outline"
className="px-3 shrink-0 gap-1 border-b border-gray-6 w-full justify-start"
>
<TabsTrigger
value="data"
variant="outline"
className="gap-2 px-3 py-2 hover:text-gray-12 rounded-none"
>
<Database className="w-4 h-4" />
{t('Data')}
</TabsTrigger>
<TabsTrigger
value="variables"
variant="outline"
className="gap-2 px-3 py-2 hover:text-gray-12 rounded-none"
>
<Variable className="w-4 h-4" />
{t('Variables')}
</TabsTrigger>
</TabsList>
<TabsContent
value="data"
className="flex-1 min-h-0 flex flex-col gap-2 mt-2"
>
<div className="flex items-center gap-2 px-5">
<SearchInput
onChange={(e) => setSearchTerm(e)}
value={searchTerm}
></SearchInput>
<Tabs
value={viewMode}
onValueChange={(v) => setViewMode(v as 'friendly' | 'advanced')}
>
<TabsList size="sm" className="shrink-0">
<TabsTrigger value="friendly" size="sm">
{t('Friendly View')}
</TabsTrigger>
<TabsTrigger value="advanced" size="sm">
{t('Advanced')}
</TabsTrigger>
</TabsList>
</Tabs>
</div>
<ScrollArea className="transition-all flex-1 w-full ">
<VirtualizedList
items={rows}
estimateSize={32}
getItemKey={(index) => rows[index].id}
renderItem={(row) => (
<DataSelectorNode
depth={row.depth}
node={row.node}
expanded={row.expanded}
setExpanded={(expanded) => setRowExpanded(row.id, expanded)}
></DataSelectorNode>
)}
/>
{filteredNodes.length === 0 && (
<div className="flex items-center justify-center gap-2 mt-5 flex-col">
<SearchXIcon className="w-[35px] h-[35px]"></SearchXIcon>
<div className="text-center font-semibold">
{t('No matching data')}
</div>
<div className="text-center ">
{t('Try adjusting your search')}
</div>
</div>
)}
</ScrollArea>
</TabsContent>
<TabsContent value="variables" className="flex-1 min-h-0 mt-2">
<VariablesTab />
</TabsContent>
</Tabs>
</div>
</div>
);
};
DataSelector.displayName = 'DataSelector';
const EMPTY_OVERRIDES: ReadonlyMap<string, boolean> = new Map();
type ExpansionState = {
scope: string;
overrides: ReadonlyMap<string, boolean>;
};
export { DataSelector };