n8n-editor-ui 1.119.1 → 1.120.0

package/dist/assets/{externalSecrets.ee.store-1z63wMHN.js → externalSecrets.ee.store-DSLmsq-8.js}

@@ -1,6 +1,6 @@
 import { C as computed, Pt as reactive } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { Cs as getExternalSecretsProviders, Es as updateProvider, Qn as useRBACStore, Ro as useSettingsStore, Ss as getExternalSecretsProvider, Ts as testExternalSecretsProviderConnection, Ys as useRootStore, bs as connectProvider, vc as defineStore, ws as reloadProvider, xs as getExternalSecrets } from "./useTelemetry-EOV0Llso.js";
-import { Bs as EnterpriseEditionFeature } from "./constants-DvlTm3U4.js";
+import { Bo as useSettingsStore, Cs as connectProvider, Ds as reloadProvider, Es as getExternalSecretsProviders, Os as testExternalSecretsProviderConnection, Qn as useRBACStore, Qs as useRootStore, Ts as getExternalSecretsProvider, ks as updateProvider, ws as getExternalSecrets, xc as defineStore } from "./useTelemetry-CWnh4Zlh.js";
+import { Hs as EnterpriseEditionFeature } from "./constants-COt-IPHd.js";
 const useExternalSecretsStore = defineStore("externalSecrets", () => {
 	const rootStore = useRootStore();
 	const settingsStore = useSettingsStore();

package/dist/assets/externalSecrets.ee.store-legacy-DaQgDltD.js

@@ -0,0 +1,145 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./useTelemetry-legacy-BDIroahM.js", "./constants-legacy-DiqA0Pu_.js"], function (_export, _context) {
+    "use strict";
+
+    var computed, reactive, useSettingsStore, connectProvider, reloadProvider, getExternalSecretsProviders, testExternalSecretsProviderConnection, useRBACStore, useRootStore, getExternalSecretsProvider, updateProvider, getExternalSecrets, defineStore, EnterpriseEditionFeature, useExternalSecretsStore;
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+        reactive = _vueRuntimeEsmBundlerLegacy003Js.Pt;
+      }, function (_useTelemetryLegacy00FJs) {
+        useSettingsStore = _useTelemetryLegacy00FJs.Bo;
+        connectProvider = _useTelemetryLegacy00FJs.Cs;
+        reloadProvider = _useTelemetryLegacy00FJs.Ds;
+        getExternalSecretsProviders = _useTelemetryLegacy00FJs.Es;
+        testExternalSecretsProviderConnection = _useTelemetryLegacy00FJs.Os;
+        useRBACStore = _useTelemetryLegacy00FJs.Qn;
+        useRootStore = _useTelemetryLegacy00FJs.Qs;
+        getExternalSecretsProvider = _useTelemetryLegacy00FJs.Ts;
+        updateProvider = _useTelemetryLegacy00FJs.ks;
+        getExternalSecrets = _useTelemetryLegacy00FJs.ws;
+        defineStore = _useTelemetryLegacy00FJs.xc;
+      }, function (_constantsLegacy00NJs) {
+        EnterpriseEditionFeature = _constantsLegacy00NJs.Hs;
+      }],
+      execute: function () {
+        //#region src/features/integrations/externalSecrets.ee/externalSecrets.ee.store.ts
+        _export("t", useExternalSecretsStore = defineStore("externalSecrets", () => {
+          const rootStore = useRootStore();
+          const settingsStore = useSettingsStore();
+          const rbacStore = useRBACStore();
+          const state = reactive({
+            providers: [],
+            secrets: {},
+            connectionState: {}
+          });
+          const isEnterpriseExternalSecretsEnabled = computed(() => settingsStore.isEnterpriseFeatureEnabled[EnterpriseEditionFeature.ExternalSecrets]);
+          const secrets = computed(() => state.secrets);
+          const providers = computed(() => state.providers);
+          const connectionState = computed(() => state.connectionState);
+          const secretsAsObject = computed(() => {
+            return Object.keys(secrets.value).reduce((providerAcc, provider) => {
+              providerAcc[provider] = secrets.value[provider]?.reduce((secretAcc, secret) => {
+                const splitSecret = secret.split(".");
+                if (splitSecret.length === 1) {
+                  secretAcc[secret] = "*********";
+                  return secretAcc;
+                }
+                const obj = secretAcc[splitSecret[0]] ?? {};
+                let acc = obj;
+                for (let i = 1; i < splitSecret.length; i++) {
+                  const key = splitSecret[i];
+                  if (i === splitSecret.length - 1) {
+                    const key$1 = splitSecret[i];
+                    acc[key$1] = "*********";
+                    continue;
+                  }
+                  if (Object.keys(acc) && !acc[key]) acc[key] = {};
+                  acc = acc[key];
+                }
+                secretAcc[splitSecret[0]] = obj;
+                return secretAcc;
+              }, {});
+              return providerAcc;
+            }, {});
+          });
+          async function fetchAllSecrets() {
+            if (rbacStore.hasScope("externalSecret:list")) try {
+              state.secrets = await getExternalSecrets(rootStore.restApiContext);
+            } catch (error) {
+              state.secrets = {};
+            }
+          }
+          async function reloadProvider$1(id) {
+            const {
+              updated
+            } = await reloadProvider(rootStore.restApiContext, id);
+            if (updated) await fetchAllSecrets();
+            return updated;
+          }
+          async function getProviders() {
+            state.providers = await getExternalSecretsProviders(rootStore.restApiContext);
+          }
+          async function testProviderConnection(id, data) {
+            return await testExternalSecretsProviderConnection(rootStore.restApiContext, id, data);
+          }
+          async function getProvider(id) {
+            const provider = await getExternalSecretsProvider(rootStore.restApiContext, id);
+            const existingProviderIndex = state.providers.findIndex(p => p.name === id);
+            if (existingProviderIndex !== -1) state.providers.splice(existingProviderIndex, 1, provider);else state.providers.push(provider);
+            return provider;
+          }
+          function updateStoredProvider(id, data) {
+            const providerIndex = state.providers.findIndex(p => p.name === id);
+            state.providers = [...state.providers.slice(0, providerIndex), {
+              ...state.providers[providerIndex],
+              ...data,
+              data: {
+                ...state.providers[providerIndex].data,
+                ...data.data
+              }
+            }, ...state.providers.slice(providerIndex + 1)];
+          }
+          async function updateProviderConnected(id, value) {
+            await connectProvider(rootStore.restApiContext, id, value);
+            await fetchAllSecrets();
+            updateStoredProvider(id, {
+              connected: value,
+              state: value ? "connected" : "initializing"
+            });
+          }
+          async function updateProvider$1(id, {
+            data
+          }) {
+            await updateProvider(rootStore.restApiContext, id, data);
+            await fetchAllSecrets();
+            updateStoredProvider(id, {
+              data
+            });
+          }
+          function setConnectionState(id, connectionState$1) {
+            state.connectionState[id] = connectionState$1;
+          }
+          return {
+            state,
+            providers,
+            secrets,
+            connectionState,
+            secretsAsObject,
+            isEnterpriseExternalSecretsEnabled,
+            fetchAllSecrets,
+            getProvider,
+            getProviders,
+            testProviderConnection,
+            updateProvider: updateProvider$1,
+            updateStoredProvider,
+            updateProviderConnected,
+            reloadProvider: reloadProvider$1,
+            setConnectionState
+          };
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{focusPanel.store-BJpwjMIG.js → focusPanel.store-DX5ouusK.js}

@@ -1,9 +1,9 @@
 import { o as __toESM } from "./chunk-6z4oVpB-.js";
 import { C as computed, It as ref } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { ot as watchOnce, pt as i18n } from "./_MapCache-Byd-DTfo.js";
-import { r as require_get } from "./truncate-DGRsht-H.js";
-import { Lo as useStorage, bc as STORES, o as useWorkflowsStore, rt as useNodeTypesStore, vc as defineStore } from "./useTelemetry-EOV0Llso.js";
-import { Gi as jsonParse, Hr as extractFromAICalls, ha as FROM_AI_AUTO_GENERATED_MARKER, ns as LOCAL_STORAGE_FOCUS_PANEL, s as PLACEHOLDER_EMPTY_WORKFLOW_ID } from "./constants-DvlTm3U4.js";
+import { ot as watchOnce, pt as i18n } from "./_MapCache-Y29RpBXS.js";
+import { r as require_get } from "./truncate-mIB0DVrK.js";
+import { Cc as STORES, o as useWorkflowsStore, rt as useNodeTypesStore, xc as defineStore, zo as useStorage } from "./useTelemetry-CWnh4Zlh.js";
+import { Gi as jsonParse, Hr as extractFromAICalls, ha as FROM_AI_AUTO_GENERATED_MARKER, ns as LOCAL_STORAGE_FOCUS_PANEL, s as PLACEHOLDER_EMPTY_WORKFLOW_ID } from "./constants-COt-IPHd.js";
 function sanitizeFromAiParameterName(s) {
 	s = s.replace(/[^a-zA-Z0-9\-]/g, "_");
 	if (s.length >= 64) s = s.slice(0, 63);

package/dist/assets/focusPanel.store-legacy-DwBTeIg0.js

@@ -0,0 +1,264 @@
+;
+(function () {
+  System.register(["./chunk-legacy-Re9CbdfL.js", "./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./_MapCache-legacy-GeIax_zP.js", "./truncate-legacy-B1qmzcuB.js", "./useTelemetry-legacy-BDIroahM.js", "./constants-legacy-DiqA0Pu_.js"], function (_export, _context) {
+    "use strict";
+
+    var __toESM, computed, ref, watchOnce, i18n, require_get, STORES, useWorkflowsStore, useNodeTypesStore, defineStore, useStorage, jsonParse, extractFromAICalls, FROM_AI_AUTO_GENERATED_MARKER, LOCAL_STORAGE_FOCUS_PANEL, PLACEHOLDER_EMPTY_WORKFLOW_ID, NODE_DENYLIST, PATH_DENYLIST, PROP_TYPE_DENYLIST, fromAIExtraProps, import_get, DEFAULT_PANEL_WIDTH, DEFAULT_FOCUS_PANEL_DATA, useFocusPanelStore;
+    //#region src/features/ndv/parameters/utils/fromAIOverride.utils.ts
+    function sanitizeFromAiParameterName(s) {
+      s = s.replace(/[^a-zA-Z0-9\-]/g, "_");
+      if (s.length >= 64) s = s.slice(0, 63);
+      return s;
+    }
+    function isExtraPropKey(extraProps, key) {
+      return extraProps.hasOwnProperty(key);
+    }
+    function updateFromAIOverrideValues(override, expr) {
+      const {
+        extraProps,
+        extraPropValues
+      } = override;
+      const overrides = parseOverrides(expr);
+      if (overrides) {
+        for (const [key, value] of Object.entries(overrides)) if (isExtraPropKey(extraProps, key)) if (extraProps[key].initialValue === value) delete extraPropValues[key];else extraPropValues[key] = value;
+      }
+    }
+    function fieldTypeToFromAiType(propType) {
+      switch (propType) {
+        case "boolean":
+        case "number":
+        case "json":
+          return propType;
+        default:
+          return "string";
+      }
+    }
+    function isFromAIOverrideValue(s) {
+      return s.startsWith(`={{ ${FROM_AI_AUTO_GENERATED_MARKER} $fromAI(`);
+    }
+    function getBestQuoteChar(description) {
+      if (description.includes("\n")) return "`";
+      if (!description.includes("`")) return "`";
+      if (!description.includes("\"")) return "\"";
+      return "'";
+    }
+    function buildUniqueName(props) {
+      const filteredPaths = props.path.split(".").filter(x => /\[\d+\]/i.test(x)).map(x => x.replaceAll(/[\[\]]/gi, ""));
+      let result = [...filteredPaths, props.parameter.displayName].join("_");
+      if (filteredPaths.length > 1) result = result.slice(-63);else result = result.slice(0, 63);
+      return result;
+    }
+    function buildValueFromOverride(override, props, includeMarker) {
+      const {
+        extraPropValues,
+        extraProps
+      } = override;
+      const marker = includeMarker ? `${FROM_AI_AUTO_GENERATED_MARKER} ` : "";
+      const key = sanitizeFromAiParameterName(buildUniqueName(props));
+      const description = extraPropValues?.description?.toString() ?? extraProps.description.initialValue;
+      const quoteChar = getBestQuoteChar(description);
+      return `={{ ${marker}$fromAI('${key}', ${quoteChar}${description.replaceAll(/\\/g, "\\\\").replaceAll(quoteChar, `\\${quoteChar}`)}${quoteChar}, '${fieldTypeToFromAiType(props.parameter.type)}') }}`;
+    }
+    function parseOverrides(expression) {
+      try {
+        const calls = extractFromAICalls(expression.replace(/\\[^`]/g, "\\\\"));
+        if (calls.length === 1) return {
+          description: calls[0].description
+        };
+      } catch (e) {}
+      return null;
+    }
+    function isDeniedNode(nodeDenyData, node) {
+      if (typeof nodeDenyData === "string") return node.type === nodeDenyData;else {
+        const [typeName, version] = nodeDenyData;
+        return node.type === typeName && node.typeVersion <= version;
+      }
+    }
+    function canBeContentOverride(props, node) {
+      if (NODE_DENYLIST.some(x => isDeniedNode(x, node))) return false;
+      if (PATH_DENYLIST.includes(props.path)) return false;
+      if (PROP_TYPE_DENYLIST.includes(props.parameter.type)) return false;
+      const codex = useNodeTypesStore().getNodeType(node.type, node?.typeVersion)?.codex;
+      if (!codex?.categories?.includes("AI") || !codex?.subcategories?.AI?.includes("Tools") || codex?.subcategories?.AI?.includes("Vector Stores")) return false;
+      return !props.parameter.noDataExpression;
+    }
+    function makeOverrideValue(context, node) {
+      if (!node) return null;
+      if (canBeContentOverride(context, node)) {
+        const fromAiOverride = {
+          type: "fromAI",
+          extraProps: fromAIExtraProps,
+          extraPropValues: {}
+        };
+        updateFromAIOverrideValues(fromAiOverride, context.value?.toString() ?? "");
+        return fromAiOverride;
+      }
+      return null;
+    }
+
+    //#endregion
+    //#region src/app/stores/focusPanel.store.ts
+    _export({
+      a: updateFromAIOverrideValues,
+      i: makeOverrideValue,
+      n: buildValueFromOverride,
+      r: isFromAIOverrideValue
+    });
+    return {
+      setters: [function (_chunkLegacy001Js) {
+        __toESM = _chunkLegacy001Js.o;
+      }, function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+        ref = _vueRuntimeEsmBundlerLegacy003Js.It;
+      }, function (_MapCacheLegacy005Js) {
+        watchOnce = _MapCacheLegacy005Js.ot;
+        i18n = _MapCacheLegacy005Js.pt;
+      }, function (_truncateLegacy00hJs) {
+        require_get = _truncateLegacy00hJs.r;
+      }, function (_useTelemetryLegacy00FJs) {
+        STORES = _useTelemetryLegacy00FJs.Cc;
+        useWorkflowsStore = _useTelemetryLegacy00FJs.o;
+        useNodeTypesStore = _useTelemetryLegacy00FJs.rt;
+        defineStore = _useTelemetryLegacy00FJs.xc;
+        useStorage = _useTelemetryLegacy00FJs.zo;
+      }, function (_constantsLegacy00NJs) {
+        jsonParse = _constantsLegacy00NJs.Gi;
+        extractFromAICalls = _constantsLegacy00NJs.Hr;
+        FROM_AI_AUTO_GENERATED_MARKER = _constantsLegacy00NJs.ha;
+        LOCAL_STORAGE_FOCUS_PANEL = _constantsLegacy00NJs.ns;
+        PLACEHOLDER_EMPTY_WORKFLOW_ID = _constantsLegacy00NJs.s;
+      }],
+      execute: function () {
+        NODE_DENYLIST = ["@n8n/n8n-nodes-langchain.toolCode", "@n8n/n8n-nodes-langchain.toolHttpRequest", "@n8n/n8n-nodes-langchain.mcpClientTool", ["@n8n/n8n-nodes-langchain.toolWorkflow", 1.2]];
+        PATH_DENYLIST = ["parameters.name", "parameters.toolName", "parameters.description", "parameters.toolDescription"];
+        PROP_TYPE_DENYLIST = ["options", "credentialsSelect"];
+        fromAIExtraProps = {
+          description: {
+            initialValue: "",
+            type: "string",
+            typeOptions: {
+              rows: 2
+            },
+            tooltip: i18n.baseText("parameterOverride.descriptionTooltip")
+          }
+        };
+        import_get = /* @__PURE__ */__toESM(require_get());
+        DEFAULT_PANEL_WIDTH = 500;
+        DEFAULT_FOCUS_PANEL_DATA = {
+          isActive: false,
+          parameters: []
+        };
+        _export("t", useFocusPanelStore = defineStore(STORES.FOCUS_PANEL, () => {
+          const workflowsStore = useWorkflowsStore();
+          const focusPanelStorage = useStorage(LOCAL_STORAGE_FOCUS_PANEL);
+          const focusPanelData = computed(() => {
+            const defaultValue = {
+              [workflowsStore.workflowId]: DEFAULT_FOCUS_PANEL_DATA
+            };
+            return focusPanelStorage.value ? jsonParse(focusPanelStorage.value, {
+              fallbackValue: defaultValue
+            }) : defaultValue;
+          });
+          const currentFocusPanelData = computed(() => focusPanelData.value[workflowsStore.workflowId] ?? DEFAULT_FOCUS_PANEL_DATA);
+          const lastFocusTimestamp = ref(0);
+          const focusPanelActive = computed(() => currentFocusPanelData.value.isActive);
+          const focusPanelWidth = computed(() => currentFocusPanelData.value.width ?? DEFAULT_PANEL_WIDTH);
+          const _focusedNodeParameters = computed(() => currentFocusPanelData.value.parameters);
+          const focusedNodeParameters = computed(() => _focusedNodeParameters.value.map(x => {
+            const node = workflowsStore.getNodeById(x.nodeId);
+            if (!node) return x;
+            const value = (0, import_get.default)(node?.parameters ?? {}, x.parameterPath.replace(/parameters\./, ""));
+            if (typeof value === "string" && isFromAIOverrideValue(value)) return x;
+            return {
+              ...x,
+              node,
+              value
+            };
+          }));
+          const resolvedParameter = computed(() => focusedNodeParameters.value[0] && isRichParameter(focusedNodeParameters.value[0]) ? focusedNodeParameters.value[0] : void 0);
+          function _setOptions({
+            parameters,
+            isActive,
+            wid = workflowsStore.workflowId,
+            width = void 0,
+            removeEmpty = false
+          }) {
+            const focusPanelDataCurrent = focusPanelData.value;
+            if (removeEmpty && "__EMPTY__" in focusPanelDataCurrent) delete focusPanelDataCurrent[PLACEHOLDER_EMPTY_WORKFLOW_ID];
+            focusPanelStorage.value = JSON.stringify({
+              ...focusPanelData.value,
+              [wid]: {
+                isActive: isActive ?? focusPanelActive.value,
+                parameters: parameters ?? _focusedNodeParameters.value,
+                width: width ?? focusPanelWidth.value
+              }
+            });
+            if (isActive) lastFocusTimestamp.value = Date.now();
+          }
+          function onNewWorkflowSave(wid) {
+            if (!currentFocusPanelData.value || !("__EMPTY__" in focusPanelData.value)) return;
+            const latestWorkflowData = focusPanelData.value[PLACEHOLDER_EMPTY_WORKFLOW_ID];
+            _setOptions({
+              wid,
+              parameters: latestWorkflowData.parameters,
+              isActive: latestWorkflowData.isActive,
+              removeEmpty: true
+            });
+          }
+          function openWithFocusedNodeParameter(nodeParameter) {
+            _setOptions({
+              parameters: [nodeParameter],
+              isActive: true
+            });
+          }
+          function closeFocusPanel() {
+            _setOptions({
+              isActive: false
+            });
+          }
+          function unsetParameters() {
+            _setOptions({
+              parameters: []
+            });
+          }
+          function toggleFocusPanel() {
+            _setOptions({
+              isActive: !focusPanelActive.value
+            });
+          }
+          function updateWidth(width) {
+            _setOptions({
+              width
+            });
+          }
+          function isRichParameter(p) {
+            return "value" in p && "node" in p;
+          }
+          const focusedNodeParametersInTelemetryFormat = computed(() => focusedNodeParameters.value.map(x => ({
+            parameterPath: x.parameterPath,
+            nodeType: isRichParameter(x) ? x.node.type : "unresolved",
+            nodeId: x.nodeId
+          })));
+          watchOnce(() => currentFocusPanelData.value, value => {
+            if (value.isActive && value.parameters.length > 0) lastFocusTimestamp.value = Date.now();
+          });
+          return {
+            focusPanelActive,
+            focusedNodeParameters,
+            focusedNodeParametersInTelemetryFormat,
+            lastFocusTimestamp,
+            focusPanelWidth,
+            resolvedParameter,
+            openWithFocusedNodeParameter,
+            isRichParameter,
+            closeFocusPanel,
+            toggleFocusPanel,
+            onNewWorkflowSave,
+            updateWidth,
+            unsetParameters
+          };
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{folders.store-Db975T-w.js → folders.store-ReN2UdkF.js}

@@ -1,6 +1,6 @@
 import { It as ref } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { gt as useI18n } from "./_MapCache-Byd-DTfo.js";
-import { Fo as getWorkflowsAndFolders, Ys as useRootStore, bc as STORES, cc as getFullApiResponse, kn as moveFolderToProject, lc as makeRestApiRequest, vc as defineStore } from "./useTelemetry-EOV0Llso.js";
+import { gt as useI18n } from "./_MapCache-Y29RpBXS.js";
+import { Cc as STORES, Fo as getWorkflowsAndFolders, Qs as useRootStore, dc as getFullApiResponse, fc as makeRestApiRequest, kn as moveFolderToProject, xc as defineStore } from "./useTelemetry-CWnh4Zlh.js";
 async function createFolder(context, projectId, name, parentFolderId) {
 	return await makeRestApiRequest(context, "POST", `/projects/${projectId}/folders`, {
 		name,