feat(salesforce): add Salesforce SOQL data source
This commit is contained in:
125 files changed
+9999
-117
No files matched your search
@@ -36,6 +36,8 @@ import type {
|
||||
import { CONNECTION_PICKER_OPTIONS, CONNECTION_PROFILES, CONNECTION_PROFILE_ICONS, type ConnectionPickerOption, type ConnectionProfileCategory, type ConnectionProfileDefinition } from "@/types/generated/connectionProfiles";
|
||||
import type { InfluxDbExternalConfig, InfluxDbVersion } from "@/types/influxdb";
|
||||
import type { VictoriaMetricsExternalConfig } from "@/types/victoriametrics";
|
||||
import type { SalesforceAuthContext, SalesforceAuthMode, SalesforceEnvironment, SalesforceExternalConfig, SalesforceOAuthAuthorizeParams, SalesforceOAuthDevicePollResult } from "@/types/salesforce";
|
||||
import { SALESFORCE_OAUTH_CALLBACK_URL } from "@/types/salesforce";
|
||||
import type { MqAdminConfig, MqAuth, MqSystemKind } from "@/types/mq";
|
||||
import type { MqttConnectionConfig } from "@/types/mqtt";
|
||||
import type { NacosAdminConfig, NacosApiPlane, NacosAuthConfig, NacosImplementation, NacosMetricsMode, NacosNamespaceInfo, NacosRNacosConsoleAuth, NacosVersionMode } from "@/types/nacos";
|
||||
@@ -1574,6 +1576,390 @@ function buildVictoriaMetricsExternalConfig(): VictoriaMetricsExternalConfig {
|
||||
return { apiPath, lookback };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Salesforce OAuth / device-code flow state
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const salesforceAuthMode = ref<SalesforceAuthMode>("token");
|
||||
const salesforceEnvironment = ref<SalesforceEnvironment>("production");
|
||||
const salesforceLoginUrl = ref("");
|
||||
const salesforceClientId = ref("");
|
||||
const salesforceClientSecret = ref("");
|
||||
// Username-password (ROPC) mode credentials. The password is never
|
||||
// round-tripped from the backend; blank on edit unless re-typed.
|
||||
const salesforceUsername = ref("");
|
||||
const salesforceUserPassword = ref("");
|
||||
|
||||
const salesforceOauthRunning = ref(false);
|
||||
const salesforceOauthError = ref("");
|
||||
const salesforceOauthSuccess = ref("");
|
||||
// When editing an existing connection whose credentials live in the backend's
|
||||
// secret store, refreshToken/clientSecret are intentionally not sent back to
|
||||
// the UI. Track "we have previously authorized" separately from whether we
|
||||
// still hold the tokens in-memory so the form can show a status chip.
|
||||
const salesforceOauthPreviouslyAuthorized = ref(false);
|
||||
|
||||
type SalesforceDevicePhase = "idle" | "polling" | "success" | "expired" | "denied" | "error";
|
||||
const salesforceDevicePhase = ref<SalesforceDevicePhase>("idle");
|
||||
const salesforceDeviceUserCode = ref("");
|
||||
const salesforceDeviceVerificationUri = ref("");
|
||||
const salesforceDeviceCode = ref("");
|
||||
const salesforceDeviceIntervalSecs = ref(5);
|
||||
const salesforceDeviceSecondsLeft = ref(0);
|
||||
const salesforceDeviceError = ref("");
|
||||
const salesforceDeviceUserCodeCopied = ref(false);
|
||||
const salesforceDeviceVerificationCopied = ref(false);
|
||||
|
||||
let salesforceDevicePollTimer: ReturnType<typeof setTimeout> | null = null;
|
||||
let salesforceDevicePollAbortId = 0;
|
||||
let salesforceDeviceExpiresTimer: ReturnType<typeof setInterval> | null = null;
|
||||
|
||||
function salesforceAuthModeFromConfig(externalConfig: unknown, fallbackPassword?: string): SalesforceAuthMode {
|
||||
const cfg = (externalConfig as SalesforceExternalConfig | undefined) ?? undefined;
|
||||
const mode = cfg?.auth?.mode;
|
||||
if (mode === "oauth" || mode === "device" || mode === "password") return mode;
|
||||
if (cfg?.auth && (cfg.auth.refreshToken || cfg.auth.clientId || cfg.auth.authorizedAt)) return "oauth";
|
||||
// No persisted auth context: if a password/token is present, treat as manual token.
|
||||
if (fallbackPassword?.trim()) return "token";
|
||||
return "token";
|
||||
}
|
||||
|
||||
function resetSalesforceOAuthFields(externalConfig?: unknown, fallbackPassword?: string) {
|
||||
const cfg = (externalConfig as SalesforceExternalConfig | undefined) ?? undefined;
|
||||
const auth = cfg?.auth;
|
||||
salesforceAuthMode.value = salesforceAuthModeFromConfig(externalConfig, fallbackPassword);
|
||||
salesforceEnvironment.value = (auth?.environment as SalesforceEnvironment) || "production";
|
||||
salesforceLoginUrl.value = auth?.loginUrl?.trim() || "";
|
||||
salesforceClientId.value = auth?.clientId?.trim() || "";
|
||||
// Client secret is never round-tripped from the backend for security; the
|
||||
// input is blank on edit and only sent when the user re-types it.
|
||||
salesforceClientSecret.value = "";
|
||||
salesforceUsername.value = auth?.username?.trim() || "";
|
||||
salesforceUserPassword.value = "";
|
||||
salesforceOauthRunning.value = false;
|
||||
salesforceOauthError.value = "";
|
||||
salesforceOauthSuccess.value = "";
|
||||
// A Client ID alone only means the form was filled in, not that anybody ever
|
||||
// signed in; claiming "authorized" from it showed a false reassurance banner.
|
||||
salesforceOauthPreviouslyAuthorized.value = !!(auth?.refreshToken || auth?.authorizedAt);
|
||||
salesforceDevicePhase.value = "idle";
|
||||
salesforceDeviceUserCode.value = "";
|
||||
salesforceDeviceVerificationUri.value = "";
|
||||
salesforceDeviceCode.value = "";
|
||||
salesforceDeviceIntervalSecs.value = 5;
|
||||
salesforceDeviceSecondsLeft.value = 0;
|
||||
salesforceDeviceError.value = "";
|
||||
salesforceDeviceUserCodeCopied.value = false;
|
||||
salesforceDeviceVerificationCopied.value = false;
|
||||
salesforceDeviceStopPolling();
|
||||
}
|
||||
|
||||
function hydrateSalesforceOAuthFields(value: unknown, fallbackPassword?: string) {
|
||||
resetSalesforceOAuthFields(value, fallbackPassword);
|
||||
}
|
||||
|
||||
function salesforceBuildAuthorizeParams(): SalesforceOAuthAuthorizeParams {
|
||||
const clientId = salesforceClientId.value.trim();
|
||||
if (!clientId) throw new Error(t("connection.salesforceOauthClientIdRequired"));
|
||||
const environment = salesforceEnvironment.value;
|
||||
const loginUrl = environment === "custom" ? salesforceLoginUrl.value.trim() : undefined;
|
||||
if (environment === "custom" && !loginUrl) {
|
||||
throw new Error(t("connection.salesforceOauthLoginUrlRequired"));
|
||||
}
|
||||
const clientSecret = salesforceClientSecret.value.trim() || undefined;
|
||||
return { environment, loginUrl, clientId, clientSecret };
|
||||
}
|
||||
|
||||
function salesforceApplyTokenToForm(token: { accessToken: string; instanceUrl: string }) {
|
||||
form.value.password = token.accessToken;
|
||||
// The backend normalizes bare hostnames; we mirror it so the card preview
|
||||
// shows the final instance URL even before the backend canonicalizes it.
|
||||
let instanceUrl = token.instanceUrl.trim();
|
||||
if (instanceUrl && !/^https?:\/\//i.test(instanceUrl)) {
|
||||
instanceUrl = `https://${instanceUrl.replace(/\/+$/, "")}`;
|
||||
}
|
||||
if (instanceUrl) {
|
||||
form.value.host = instanceUrl.replace(/\/+$/, "");
|
||||
}
|
||||
}
|
||||
|
||||
function salesforceBuildAuthContext(mode: SalesforceAuthMode, token?: { refreshToken?: string }): SalesforceAuthContext | undefined {
|
||||
if (mode === "token") return undefined;
|
||||
const context: SalesforceAuthContext = {
|
||||
mode,
|
||||
environment: salesforceEnvironment.value,
|
||||
clientId: salesforceClientId.value.trim() || undefined,
|
||||
authorizedAt: new Date().toISOString(),
|
||||
};
|
||||
if (salesforceEnvironment.value === "custom") {
|
||||
context.loginUrl = salesforceLoginUrl.value.trim() || undefined;
|
||||
}
|
||||
// Only forward the client secret when the user explicitly typed it in this
|
||||
// session — otherwise we would overwrite the backend-stored secret with "".
|
||||
if (salesforceClientSecret.value.trim()) {
|
||||
context.clientSecret = salesforceClientSecret.value.trim();
|
||||
}
|
||||
if (mode === "password") {
|
||||
context.username = salesforceUsername.value.trim() || undefined;
|
||||
if (salesforceUserPassword.value) {
|
||||
context.password = salesforceUserPassword.value;
|
||||
}
|
||||
}
|
||||
if (token?.refreshToken) {
|
||||
context.refreshToken = token.refreshToken;
|
||||
}
|
||||
return context;
|
||||
}
|
||||
|
||||
function salesforceMergeAuthIntoExternalConfig(mode: SalesforceAuthMode, token?: { refreshToken?: string }) {
|
||||
const existing = (form.value.external_config && typeof form.value.external_config === "object" ? (form.value.external_config as Record<string, unknown>) : {}) as SalesforceExternalConfig & Record<string, unknown>;
|
||||
const auth = salesforceBuildAuthContext(mode, token);
|
||||
if (!auth) {
|
||||
const { auth: _dropped, ...rest } = existing;
|
||||
form.value.external_config = Object.keys(rest).length > 0 ? rest : undefined;
|
||||
return;
|
||||
}
|
||||
// Preserve an existing refreshToken when the user re-authorizes without the
|
||||
// backend returning a new one (e.g. refresh flow that omits a rotation).
|
||||
if (!auth.refreshToken && existing.auth?.refreshToken) {
|
||||
auth.refreshToken = existing.auth.refreshToken;
|
||||
}
|
||||
// Same for the ROPC password: it is not round-tripped for display, so an
|
||||
// edit-without-retype must not clobber the stored credential.
|
||||
if (!auth.password && existing.auth?.password) {
|
||||
auth.password = existing.auth.password;
|
||||
}
|
||||
form.value.external_config = { ...existing, auth };
|
||||
}
|
||||
|
||||
async function salesforceStartBrowserAuthorize() {
|
||||
salesforceOauthError.value = "";
|
||||
salesforceOauthSuccess.value = "";
|
||||
salesforceOauthPreviouslyAuthorized.value = false;
|
||||
let params: SalesforceOAuthAuthorizeParams;
|
||||
try {
|
||||
params = salesforceBuildAuthorizeParams();
|
||||
} catch (e) {
|
||||
salesforceOauthError.value = errorMessage(e);
|
||||
return;
|
||||
}
|
||||
salesforceOauthRunning.value = true;
|
||||
try {
|
||||
const token = await api.salesforceOauthBrowserAuthorize(params);
|
||||
salesforceApplyTokenToForm(token);
|
||||
salesforceMergeAuthIntoExternalConfig("oauth", token);
|
||||
salesforceOauthSuccess.value = t("connection.salesforceOauthSuccess", { instanceUrl: token.instanceUrl });
|
||||
salesforceOauthPreviouslyAuthorized.value = true;
|
||||
} catch (e) {
|
||||
salesforceOauthError.value = errorMessage(e);
|
||||
} finally {
|
||||
salesforceOauthRunning.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
async function salesforceStartPasswordLogin() {
|
||||
salesforceOauthError.value = "";
|
||||
salesforceOauthSuccess.value = "";
|
||||
salesforceOauthPreviouslyAuthorized.value = false;
|
||||
let params: SalesforceOAuthAuthorizeParams;
|
||||
try {
|
||||
params = salesforceBuildAuthorizeParams();
|
||||
} catch (e) {
|
||||
salesforceOauthError.value = errorMessage(e);
|
||||
return;
|
||||
}
|
||||
const username = salesforceUsername.value.trim();
|
||||
if (!username) {
|
||||
salesforceOauthError.value = t("connection.salesforceUsernameRequired");
|
||||
return;
|
||||
}
|
||||
if (!salesforceUserPassword.value) {
|
||||
salesforceOauthError.value = t("connection.salesforceUserPasswordRequired");
|
||||
return;
|
||||
}
|
||||
salesforceOauthRunning.value = true;
|
||||
try {
|
||||
const token = await api.salesforceOauthPasswordLogin(params, username, salesforceUserPassword.value);
|
||||
salesforceApplyTokenToForm(token);
|
||||
salesforceMergeAuthIntoExternalConfig("password", token);
|
||||
salesforceOauthSuccess.value = t("connection.salesforceOauthSuccess", { instanceUrl: token.instanceUrl });
|
||||
salesforceOauthPreviouslyAuthorized.value = true;
|
||||
} catch (e) {
|
||||
salesforceOauthError.value = errorMessage(e);
|
||||
} finally {
|
||||
salesforceOauthRunning.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
function salesforceDeviceStopPolling() {
|
||||
salesforceDevicePollAbortId++;
|
||||
if (salesforceDevicePollTimer) {
|
||||
clearTimeout(salesforceDevicePollTimer);
|
||||
salesforceDevicePollTimer = null;
|
||||
}
|
||||
if (salesforceDeviceExpiresTimer) {
|
||||
clearInterval(salesforceDeviceExpiresTimer);
|
||||
salesforceDeviceExpiresTimer = null;
|
||||
}
|
||||
}
|
||||
|
||||
function salesforceDeviceStartExpiryCountdown(expiresInSecs: number) {
|
||||
salesforceDeviceSecondsLeft.value = Math.max(0, Math.floor(expiresInSecs));
|
||||
if (salesforceDeviceExpiresTimer) clearInterval(salesforceDeviceExpiresTimer);
|
||||
salesforceDeviceExpiresTimer = setInterval(() => {
|
||||
salesforceDeviceSecondsLeft.value = Math.max(0, salesforceDeviceSecondsLeft.value - 1);
|
||||
if (salesforceDeviceSecondsLeft.value <= 0 && salesforceDevicePhase.value === "polling") {
|
||||
salesforceDeviceStopPolling();
|
||||
salesforceDevicePhase.value = "expired";
|
||||
}
|
||||
}, 1000);
|
||||
}
|
||||
|
||||
async function salesforceDeviceRequestCode() {
|
||||
salesforceOauthError.value = "";
|
||||
salesforceOauthSuccess.value = "";
|
||||
salesforceOauthPreviouslyAuthorized.value = false;
|
||||
salesforceDeviceError.value = "";
|
||||
salesforceDeviceUserCode.value = "";
|
||||
salesforceDeviceVerificationUri.value = "";
|
||||
salesforceDeviceUserCodeCopied.value = false;
|
||||
salesforceDeviceVerificationCopied.value = false;
|
||||
let params: SalesforceOAuthAuthorizeParams;
|
||||
try {
|
||||
params = salesforceBuildAuthorizeParams();
|
||||
} catch (e) {
|
||||
salesforceDeviceError.value = errorMessage(e);
|
||||
salesforceDevicePhase.value = "error";
|
||||
return;
|
||||
}
|
||||
salesforceOauthRunning.value = true;
|
||||
salesforceDevicePhase.value = "idle";
|
||||
try {
|
||||
const start = await api.salesforceOauthDeviceStart(params);
|
||||
salesforceDeviceUserCode.value = start.userCode;
|
||||
salesforceDeviceVerificationUri.value = start.verificationUri;
|
||||
salesforceDeviceCode.value = start.deviceCode;
|
||||
salesforceDeviceIntervalSecs.value = Math.max(1, start.intervalSecs || 5);
|
||||
salesforceDevicePhase.value = "polling";
|
||||
salesforceDeviceStartExpiryCountdown(start.expiresInSecs);
|
||||
await salesforceDevicePollLoop(params, start.deviceCode, salesforceDeviceIntervalSecs.value, salesforceDevicePollAbortId);
|
||||
} catch (e) {
|
||||
salesforceDeviceError.value = errorMessage(e);
|
||||
salesforceDevicePhase.value = "error";
|
||||
salesforceDeviceStopPolling();
|
||||
} finally {
|
||||
salesforceOauthRunning.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
async function salesforceDevicePollLoop(params: SalesforceOAuthAuthorizeParams, deviceCode: string, intervalSecs: number, abortId: number): Promise<void> {
|
||||
while (salesforceDevicePhase.value === "polling" && abortId === salesforceDevicePollAbortId) {
|
||||
await new Promise<void>((resolve) => {
|
||||
salesforceDevicePollTimer = setTimeout(() => resolve(), intervalSecs * 1000);
|
||||
});
|
||||
if (abortId !== salesforceDevicePollAbortId) return;
|
||||
let result: SalesforceOAuthDevicePollResult;
|
||||
try {
|
||||
result = await api.salesforceOauthDevicePoll(params, deviceCode, intervalSecs);
|
||||
} catch (e) {
|
||||
// Transient network error: keep polling until the code expires.
|
||||
if (salesforceDeviceSecondsLeft.value <= 0) {
|
||||
salesforceDevicePhase.value = "expired";
|
||||
salesforceDeviceStopPolling();
|
||||
return;
|
||||
}
|
||||
salesforceDeviceError.value = errorMessage(e);
|
||||
continue;
|
||||
}
|
||||
if (abortId !== salesforceDevicePollAbortId) return;
|
||||
if (result.status === "pending") {
|
||||
salesforceDeviceIntervalSecs.value = Math.max(1, result.intervalSecs || intervalSecs);
|
||||
continue;
|
||||
}
|
||||
salesforceDeviceStopPolling();
|
||||
if (result.status === "success") {
|
||||
salesforceApplyTokenToForm(result.token);
|
||||
salesforceMergeAuthIntoExternalConfig("device", result.token);
|
||||
salesforceOauthSuccess.value = t("connection.salesforceOauthSuccess", { instanceUrl: result.token.instanceUrl });
|
||||
salesforceOauthPreviouslyAuthorized.value = true;
|
||||
salesforceDevicePhase.value = "success";
|
||||
return;
|
||||
}
|
||||
if (result.status === "expired") {
|
||||
salesforceDevicePhase.value = "expired";
|
||||
return;
|
||||
}
|
||||
if (result.status === "denied") {
|
||||
salesforceDeviceError.value = result.reason || t("connection.salesforceDeviceDenied");
|
||||
salesforceDevicePhase.value = "denied";
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function salesforceDeviceCancel() {
|
||||
salesforceDeviceStopPolling();
|
||||
salesforceDevicePhase.value = "idle";
|
||||
salesforceDeviceUserCode.value = "";
|
||||
salesforceDeviceVerificationUri.value = "";
|
||||
salesforceDeviceCode.value = "";
|
||||
}
|
||||
|
||||
function salesforceDeviceRestart() {
|
||||
salesforceDeviceCancel();
|
||||
salesforceDeviceError.value = "";
|
||||
salesforceOauthError.value = "";
|
||||
}
|
||||
|
||||
async function salesforceCopyUserCode() {
|
||||
if (!salesforceDeviceUserCode.value) return;
|
||||
await copyToClipboard(salesforceDeviceUserCode.value);
|
||||
salesforceDeviceUserCodeCopied.value = true;
|
||||
setTimeout(() => {
|
||||
salesforceDeviceUserCodeCopied.value = false;
|
||||
}, 1500);
|
||||
}
|
||||
|
||||
async function salesforceCopyVerificationUri() {
|
||||
if (!salesforceDeviceVerificationUri.value) return;
|
||||
await copyToClipboard(salesforceDeviceVerificationUri.value);
|
||||
salesforceDeviceVerificationCopied.value = true;
|
||||
setTimeout(() => {
|
||||
salesforceDeviceVerificationCopied.value = false;
|
||||
}, 1500);
|
||||
}
|
||||
|
||||
function salesforceOpenVerificationPage() {
|
||||
if (!salesforceDeviceVerificationUri.value) return;
|
||||
// Same pattern as the update-flow "open release notes" action: defer to the
|
||||
// shell helper that picks the right opener for desktop vs. web.
|
||||
void (async () => {
|
||||
try {
|
||||
if (isDesktop) {
|
||||
const { open } = await import("@tauri-apps/plugin-shell");
|
||||
await open(salesforceDeviceVerificationUri.value);
|
||||
} else {
|
||||
globalThis.open(salesforceDeviceVerificationUri.value, "_blank", "noopener,noreferrer");
|
||||
}
|
||||
} catch (e) {
|
||||
salesforceDeviceError.value = errorMessage(e);
|
||||
}
|
||||
})();
|
||||
}
|
||||
|
||||
function salesforceSetAuthMode(mode: SalesforceAuthMode) {
|
||||
// Switching modes resets any in-flight state so stale tokens from one flow
|
||||
// never leak into another.
|
||||
if (salesforceOauthRunning.value && mode !== salesforceAuthMode.value) return;
|
||||
salesforceAuthMode.value = mode;
|
||||
salesforceOauthError.value = "";
|
||||
salesforceOauthSuccess.value = "";
|
||||
if (mode !== "device") {
|
||||
salesforceDeviceCancel();
|
||||
salesforceDeviceError.value = "";
|
||||
}
|
||||
}
|
||||
|
||||
watch(influxDbVersion, (version, previousVersion) => {
|
||||
if (form.value.db_type !== "influxdb") return;
|
||||
if (version === "2" || version === "3") {
|
||||
@@ -2546,6 +2932,9 @@ function applyProfile(val: string, preserveConnectionFields = false) {
|
||||
form.value.connection_string = undefined;
|
||||
form.value.url_params = "";
|
||||
}
|
||||
if (profile.type === "salesforce") {
|
||||
resetSalesforceOAuthFields(form.value.external_config, form.value.password);
|
||||
}
|
||||
resetHiveKerberosFields(profile.type === "hive" || profile.type === "argo" || profile.type === "kyuubi" || profile.type === "impala" ? form.value : undefined);
|
||||
}
|
||||
if (profile.type === "meilisearch") {
|
||||
@@ -2777,6 +3166,11 @@ watch(
|
||||
} else {
|
||||
resetVictoriaMetricsFields();
|
||||
}
|
||||
if (config.db_type === "salesforce") {
|
||||
hydrateSalesforceOAuthFields(config.external_config, config.password);
|
||||
} else {
|
||||
resetSalesforceOAuthFields(undefined, undefined);
|
||||
}
|
||||
resetElasticsearchProxyFields(config.db_type === "elasticsearch" ? config.external_config : undefined);
|
||||
resetHiveKerberosFields(config.db_type === "hive" || config.db_type === "argo" || config.db_type === "kyuubi" || config.db_type === "impala" ? config : undefined);
|
||||
resetDamengJvmOptions(config.db_type === "dameng" ? config : undefined);
|
||||
@@ -4426,6 +4820,51 @@ function connectionConfigForSubmit(id: string, generatedName = "", validatePlugi
|
||||
config.connection_string = undefined;
|
||||
config.database = "metrics";
|
||||
config.username = config.username.trim();
|
||||
} else if (config.db_type === "salesforce") {
|
||||
// Token-mode connections never carry auth context (the access token itself is
|
||||
// the credential in `password`). OAuth/device modes merge the auth context
|
||||
// into `external_config.auth`; the backend handles refreshToken encryption.
|
||||
config.connection_string = undefined;
|
||||
config.database = undefined;
|
||||
config.username = config.username.trim();
|
||||
const existing = (config.external_config && typeof config.external_config === "object" ? (config.external_config as Record<string, unknown>) : {}) as SalesforceExternalConfig & Record<string, unknown>;
|
||||
if (salesforceAuthMode.value === "token") {
|
||||
const { auth: _dropped, ...rest } = existing;
|
||||
config.external_config = Object.keys(rest).length > 0 ? rest : undefined;
|
||||
} else {
|
||||
// Preserve an existing refreshToken/clientSecret when the user saves the
|
||||
// form without re-authorizing or re-typing them (they're not round-tripped
|
||||
// from the backend). The hydrate step flagged this via
|
||||
// `salesforceOauthPreviouslyAuthorized`.
|
||||
const auth: SalesforceAuthContext = {
|
||||
mode: salesforceAuthMode.value,
|
||||
environment: salesforceEnvironment.value,
|
||||
clientId: salesforceClientId.value.trim() || existing.auth?.clientId,
|
||||
authorizedAt: existing.auth?.authorizedAt,
|
||||
};
|
||||
if (salesforceEnvironment.value === "custom") {
|
||||
auth.loginUrl = salesforceLoginUrl.value.trim() || existing.auth?.loginUrl;
|
||||
}
|
||||
if (salesforceClientSecret.value.trim()) {
|
||||
auth.clientSecret = salesforceClientSecret.value.trim();
|
||||
} else if (existing.auth?.clientSecret) {
|
||||
// Preserve secret indicator without leaking the value to the client.
|
||||
auth.clientSecret = existing.auth.clientSecret;
|
||||
}
|
||||
if (salesforceAuthMode.value === "password") {
|
||||
auth.username = salesforceUsername.value.trim() || existing.auth?.username;
|
||||
if (salesforceUserPassword.value) {
|
||||
auth.password = salesforceUserPassword.value;
|
||||
} else if (existing.auth?.password) {
|
||||
// Stored ROPC credential (scrubbed into the backend secret store);
|
||||
// keep it when the user edits the connection without retyping.
|
||||
auth.password = existing.auth.password;
|
||||
}
|
||||
} else if (existing.auth?.refreshToken) {
|
||||
auth.refreshToken = existing.auth.refreshToken;
|
||||
}
|
||||
config.external_config = { ...existing, auth };
|
||||
}
|
||||
} else if (config.db_type === "elasticsearch") {
|
||||
config.external_config = buildElasticsearchExternalConfig(elasticsearchConnectionMode.value, elasticsearchKibanaBasePath.value, elasticsearchConnectivityCheckPath.value, elasticsearchIndexGroupingPattern.value, elasticsearchConnectivityCheckDisabled.value);
|
||||
} else if (config.db_type === "meilisearch") {
|
||||
@@ -5476,6 +5915,7 @@ function resetForm(options: { preservePickerState?: boolean } = {}) {
|
||||
appliedConnectionUrlInput.value = "";
|
||||
resetMeilisearchHostInput();
|
||||
oracleTnsAdminPath.value = "";
|
||||
resetSalesforceOAuthFields(undefined, undefined);
|
||||
if (!options.preservePickerState) {
|
||||
dialogStep.value = "select";
|
||||
dbSearchQuery.value = "";
|
||||
@@ -6366,6 +6806,9 @@ onMounted(async () => {
|
||||
onUnmounted(() => {
|
||||
unlistenAgentInstallProgress?.();
|
||||
unlistenAgentInstallProgress = null;
|
||||
// Stop any in-flight Salesforce device-code poll / expiry countdown so
|
||||
// closing the dialog does not leave orphan timers running.
|
||||
salesforceDeviceStopPolling();
|
||||
});
|
||||
|
||||
function openExternalUrl(url: string) {
|
||||
@@ -6521,7 +6964,7 @@ function openExternalUrl(url: string) {
|
||||
|
||||
<TabsContent value="connection" class="m-0 flex min-h-0 flex-1 flex-col overflow-hidden">
|
||||
<div class="connection-form-body grid min-h-0 flex-1 scroll-pb-6 gap-4 overflow-y-auto pt-4 pr-2 pb-6" :class="{ 'connection-form-body--nacos': form.db_type === 'nacos' }">
|
||||
<div v-if="!isPluginConnection && !isJdbcConnection && form.db_type !== 'nacos' && form.db_type !== 'consul' && form.db_type !== 'mq'" class="grid grid-cols-4 items-center gap-4">
|
||||
<div v-if="!isPluginConnection && !isJdbcConnection && form.db_type !== 'nacos' && form.db_type !== 'consul' && form.db_type !== 'mq' && form.db_type !== 'salesforce'" class="grid grid-cols-4 items-center gap-4">
|
||||
<Label :class="connectionLabelClass">{{ t("connection.connectionUrlOptional") }}</Label>
|
||||
<div class="col-span-3 flex items-center gap-1">
|
||||
<Input v-model="connectionUrlInput" class="flex-1" :placeholder="connectionUrlPlaceholder" @keydown.enter.prevent="applyConnectionUrl" />
|
||||
@@ -7943,6 +8386,289 @@ function openExternalUrl(url: string) {
|
||||
<CloudflareD1ConnectionFields v-model:account-id="form.host" v-model:database-id="form.database" v-model:api-token="form.password" />
|
||||
</template>
|
||||
|
||||
<!-- Salesforce: instance URL + access token (SOQL) -->
|
||||
<template v-else-if="form.db_type === 'salesforce'">
|
||||
<!-- Instance URL (always visible so the user can confirm the
|
||||
target org; OAuth/device flows overwrite it after a
|
||||
successful authorize) -->
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<Label :class="connectionLabelSmallClass">{{ t("connection.salesforceInstanceUrl") }}</Label>
|
||||
<div class="col-span-3 space-y-1.5">
|
||||
<div class="flex gap-2">
|
||||
<Input v-model="form.host" class="flex-1" :placeholder="t('connection.salesforceInstanceUrlPlaceholder')" />
|
||||
<Input v-model.number="form.port" type="number" class="w-24 shrink-0" />
|
||||
</div>
|
||||
<p class="text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceInstanceUrlHint") }}</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Authentication mode picker -->
|
||||
<div class="grid grid-cols-4 items-center gap-4">
|
||||
<Label :class="connectionLabelSmallClass">{{ t("connection.salesforceAuthMode") }}</Label>
|
||||
<div class="col-span-3 grid h-8 grid-cols-4 overflow-hidden rounded-md border border-input bg-muted/30 p-0.5">
|
||||
<button
|
||||
type="button"
|
||||
class="h-7 rounded-sm px-2 text-xs transition-colors"
|
||||
:class="salesforceAuthMode === 'token' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
|
||||
:aria-pressed="salesforceAuthMode === 'token'"
|
||||
:disabled="salesforceOauthRunning"
|
||||
@click="salesforceSetAuthMode('token')"
|
||||
>
|
||||
{{ t("connection.salesforceAuthModeToken") }}
|
||||
</button>
|
||||
<button
|
||||
type="button"
|
||||
class="h-7 rounded-sm px-2 text-xs transition-colors"
|
||||
:class="salesforceAuthMode === 'oauth' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground disabled:text-muted-foreground/50'"
|
||||
:aria-pressed="salesforceAuthMode === 'oauth'"
|
||||
:disabled="salesforceOauthRunning || !isDesktop"
|
||||
:title="!isDesktop ? t('connection.salesforceAuthModeOauthDesktopOnly') : undefined"
|
||||
@click="salesforceSetAuthMode('oauth')"
|
||||
>
|
||||
{{ t("connection.salesforceAuthModeOauth") }}
|
||||
</button>
|
||||
<button
|
||||
type="button"
|
||||
class="h-7 rounded-sm px-2 text-xs transition-colors"
|
||||
:class="salesforceAuthMode === 'device' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
|
||||
:aria-pressed="salesforceAuthMode === 'device'"
|
||||
:disabled="salesforceOauthRunning"
|
||||
@click="salesforceSetAuthMode('device')"
|
||||
>
|
||||
{{ t("connection.salesforceAuthModeDevice") }}
|
||||
</button>
|
||||
<button
|
||||
type="button"
|
||||
class="h-7 rounded-sm px-2 text-xs transition-colors"
|
||||
:class="salesforceAuthMode === 'password' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
|
||||
:aria-pressed="salesforceAuthMode === 'password'"
|
||||
:disabled="salesforceOauthRunning"
|
||||
@click="salesforceSetAuthMode('password')"
|
||||
>
|
||||
{{ t("connection.salesforceAuthModePassword") }}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
<div v-if="!isDesktop && salesforceAuthMode === 'oauth'" class="grid grid-cols-4 items-start gap-4">
|
||||
<span />
|
||||
<p class="col-span-3 text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceAuthModeOauthDesktopOnly") }}</p>
|
||||
</div>
|
||||
|
||||
<!-- Manual access token -->
|
||||
<template v-if="salesforceAuthMode === 'token'">
|
||||
<div class="grid grid-cols-4 items-center gap-4">
|
||||
<Label :class="connectionLabelClass">{{ t("connection.salesforceAccessToken") }}</Label>
|
||||
<PasswordInput v-model="form.password" class="col-span-3" :placeholder="t('connection.salesforceAccessTokenPlaceholder')" />
|
||||
</div>
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<span />
|
||||
<p class="col-span-3 text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceAccessTokenHint") }}</p>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<!-- Shared OAuth / device-code fields -->
|
||||
<template v-else>
|
||||
<div class="grid grid-cols-4 items-center gap-4">
|
||||
<Label :class="connectionLabelSmallClass">{{ t("connection.salesforceEnvironment") }}</Label>
|
||||
<Select v-model="salesforceEnvironment" :disabled="salesforceOauthRunning">
|
||||
<SelectTrigger class="col-span-3">
|
||||
<SelectValue />
|
||||
</SelectTrigger>
|
||||
<SelectContent>
|
||||
<SelectItem value="production">{{ t("connection.salesforceEnvironmentProduction") }}</SelectItem>
|
||||
<SelectItem value="sandbox">{{ t("connection.salesforceEnvironmentSandbox") }}</SelectItem>
|
||||
<SelectItem value="custom">{{ t("connection.salesforceEnvironmentCustom") }}</SelectItem>
|
||||
</SelectContent>
|
||||
</Select>
|
||||
</div>
|
||||
<div v-if="salesforceEnvironment === 'custom'" class="grid grid-cols-4 items-start gap-4">
|
||||
<Label :class="connectionLabelClass">{{ t("connection.salesforceLoginUrl") }}</Label>
|
||||
<div class="col-span-3 space-y-1.5">
|
||||
<Input v-model="salesforceLoginUrl" :placeholder="t('connection.salesforceLoginUrlPlaceholder')" :disabled="salesforceOauthRunning" />
|
||||
<p class="text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceLoginUrlHint") }}</p>
|
||||
</div>
|
||||
</div>
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<Label :class="connectionLabelSmallClass">
|
||||
{{ t("connection.salesforceClientId") }}
|
||||
<span class="ml-1 text-destructive">*</span>
|
||||
</Label>
|
||||
<div class="col-span-3 space-y-1.5">
|
||||
<Input v-model="salesforceClientId" :placeholder="t('connection.salesforceClientIdPlaceholder')" :disabled="salesforceOauthRunning" autocomplete="off" />
|
||||
<!-- The callback URL only matters for the browser redirect flow; the
|
||||
other two modes never see one, so keep it out of their way. -->
|
||||
<p v-if="salesforceAuthMode === 'oauth'" class="text-xs leading-5 text-muted-foreground">
|
||||
{{ t("connection.salesforceClientIdHint", { callbackUrl: SALESFORCE_OAUTH_CALLBACK_URL }) }}
|
||||
</p>
|
||||
<p v-else class="text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceClientIdHintShared") }}</p>
|
||||
</div>
|
||||
</div>
|
||||
<div class="grid grid-cols-4 items-center gap-4">
|
||||
<Label :class="connectionLabelClass">{{ t("connection.salesforceClientSecret") }}</Label>
|
||||
<div class="col-span-3 space-y-1.5">
|
||||
<PasswordInput v-model="salesforceClientSecret" :placeholder="t('connection.salesforceClientSecretPlaceholder')" :disabled="salesforceOauthRunning" autocomplete="new-password" />
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Username & password (ROPC) credentials -->
|
||||
<template v-if="salesforceAuthMode === 'password'">
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<Label :class="connectionLabelClass">{{ t("connection.salesforceUsernameLabel") }}</Label>
|
||||
<div class="col-span-3 space-y-1.5">
|
||||
<Input v-model="salesforceUsername" :placeholder="t('connection.salesforceUsernamePlaceholder')" :disabled="salesforceOauthRunning" autocomplete="off" />
|
||||
<p class="text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceUsernameHint") }}</p>
|
||||
</div>
|
||||
</div>
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<Label :class="connectionLabelClass">{{ t("connection.salesforceUserPasswordLabel") }}</Label>
|
||||
<div class="col-span-3 space-y-1.5">
|
||||
<PasswordInput v-model="salesforceUserPassword" :placeholder="t('connection.salesforceUserPasswordPlaceholder')" :disabled="salesforceOauthRunning" autocomplete="new-password" />
|
||||
<p class="text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceUserPasswordHint") }}</p>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<!-- Previously-authorized banner (edit flow) -->
|
||||
<div v-if="salesforceOauthPreviouslyAuthorized && !salesforceOauthRunning && salesforceDevicePhase !== 'polling'" class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex items-center gap-2 rounded-md border border-emerald-500/30 bg-emerald-500/10 px-3 py-2 text-xs text-emerald-700 dark:text-emerald-300">
|
||||
<ShieldCheck class="h-4 w-4 shrink-0" />
|
||||
<span>{{ t("connection.salesforceOauthAuthorized") }}</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Browser OAuth action -->
|
||||
<template v-if="salesforceAuthMode === 'oauth'">
|
||||
<div class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex items-center gap-2">
|
||||
<Button type="button" :disabled="salesforceOauthRunning || !salesforceClientId.trim() || !isDesktop" @click="salesforceStartBrowserAuthorize">
|
||||
<Loader2 v-if="salesforceOauthRunning" class="mr-2 h-4 w-4 animate-spin" />
|
||||
{{ salesforceOauthRunning ? t("connection.salesforceOauthAuthorizing") : salesforceOauthPreviouslyAuthorized ? t("connection.salesforceOauthReauthorize") : t("connection.salesforceOauthAuthorize") }}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
<div v-if="salesforceOauthRunning" class="grid grid-cols-4 items-start gap-4">
|
||||
<span />
|
||||
<p class="col-span-3 text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceOauthAuthorizingHint") }}</p>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<!-- Username-password sign in -->
|
||||
<template v-if="salesforceAuthMode === 'password'">
|
||||
<div class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex items-center gap-2">
|
||||
<Button type="button" :disabled="salesforceOauthRunning || !salesforceClientId.trim() || !salesforceUsername.trim() || !salesforceUserPassword" @click="salesforceStartPasswordLogin">
|
||||
<Loader2 v-if="salesforceOauthRunning" class="mr-2 h-4 w-4 animate-spin" />
|
||||
{{ salesforceOauthRunning ? t("connection.salesforceOauthAuthorizing") : salesforceOauthPreviouslyAuthorized ? t("connection.salesforcePasswordSignInAgain") : t("connection.salesforcePasswordSignIn") }}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<span />
|
||||
<p class="col-span-3 text-xs leading-5 text-muted-foreground">{{ t("connection.salesforcePasswordRopcNote") }}</p>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<!-- Device-code flow -->
|
||||
<template v-if="salesforceAuthMode === 'device'">
|
||||
<div v-if="salesforceDevicePhase === 'idle' || salesforceDevicePhase === 'error'" class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex items-center gap-2">
|
||||
<Button type="button" :disabled="salesforceOauthRunning || !salesforceClientId.trim()" @click="salesforceDeviceRequestCode">
|
||||
<Loader2 v-if="salesforceOauthRunning" class="mr-2 h-4 w-4 animate-spin" />
|
||||
{{ t("connection.salesforceDeviceGetCode") }}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
<div v-if="salesforceDevicePhase === 'idle' || salesforceDevicePhase === 'error'" class="grid grid-cols-4 items-start gap-4">
|
||||
<span />
|
||||
<p class="col-span-3 text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceDeviceFlowNote") }}</p>
|
||||
</div>
|
||||
|
||||
<template v-if="salesforceDevicePhase === 'polling'">
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<Label :class="connectionLabelSmallClass">{{ t("connection.salesforceDeviceUserCodeLabel") }}</Label>
|
||||
<div class="col-span-3 space-y-1.5">
|
||||
<div class="flex items-center gap-2 rounded-md border border-input bg-muted/40 px-3 py-2">
|
||||
<span class="font-mono text-lg font-semibold tracking-widest">{{ salesforceDeviceUserCode }}</span>
|
||||
<Button type="button" variant="ghost" size="icon" class="h-7 w-7" @click="salesforceCopyUserCode">
|
||||
<Check v-if="salesforceDeviceUserCodeCopied" class="h-4 w-4 text-emerald-600" />
|
||||
<Copy v-else class="h-4 w-4" />
|
||||
</Button>
|
||||
</div>
|
||||
<div v-if="salesforceDeviceVerificationUri" class="flex items-center gap-2 text-xs">
|
||||
<a class="text-primary underline underline-offset-2 hover:no-underline" href="#" @click.prevent="salesforceOpenVerificationPage">{{ t("connection.salesforceDeviceOpenVerification") }}</a>
|
||||
<code class="truncate rounded bg-muted px-1 py-0.5 text-[11px]">{{ salesforceDeviceVerificationUri }}</code>
|
||||
<Button type="button" variant="ghost" size="icon" class="h-6 w-6" @click="salesforceCopyVerificationUri">
|
||||
<Check v-if="salesforceDeviceVerificationCopied" class="h-3.5 w-3.5 text-emerald-600" />
|
||||
<Copy v-else class="h-3.5 w-3.5" />
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex items-center gap-3 text-xs text-muted-foreground">
|
||||
<Loader2 class="h-4 w-4 animate-spin" />
|
||||
<span>{{ t("connection.salesforceDevicePolling") }}</span>
|
||||
<span v-if="salesforceDeviceSecondsLeft > 0">· {{ t("connection.salesforceDeviceSecondsLeft", { seconds: salesforceDeviceSecondsLeft }) }}</span>
|
||||
<Button type="button" variant="outline" size="sm" class="ml-auto" @click="salesforceDeviceCancel">
|
||||
{{ t("connection.salesforceDeviceCancel") }}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="grid grid-cols-4 items-start gap-4">
|
||||
<span />
|
||||
<p class="col-span-3 text-xs leading-5 text-muted-foreground">{{ t("connection.salesforceDevicePollingHint") }}</p>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<div v-else-if="salesforceDevicePhase === 'expired'" class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex flex-col gap-2 rounded-md border border-amber-500/30 bg-amber-500/10 px-3 py-2 text-xs">
|
||||
<span class="text-amber-700 dark:text-amber-300">{{ t("connection.salesforceDeviceExpired") }}</span>
|
||||
<Button type="button" size="sm" variant="outline" class="self-start" @click="salesforceDeviceRestart">
|
||||
{{ t("connection.salesforceDeviceRestart") }}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div v-else-if="salesforceDevicePhase === 'denied'" class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex flex-col gap-2 rounded-md border border-destructive/40 bg-destructive/5 px-3 py-2 text-xs">
|
||||
<span class="text-destructive">{{ salesforceDeviceError || t("connection.salesforceDeviceDenied") }}</span>
|
||||
<Button type="button" size="sm" variant="outline" class="self-start" @click="salesforceDeviceRestart">
|
||||
{{ t("connection.salesforceDeviceRestart") }}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
</template>
|
||||
|
||||
<!-- Shared status / error strip (oauth success + any error) -->
|
||||
<div v-if="salesforceOauthSuccess && (salesforceAuthMode === 'oauth' || salesforceAuthMode === 'password' || salesforceDevicePhase === 'success')" class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 flex items-center gap-2 rounded-md border border-emerald-500/30 bg-emerald-500/10 px-3 py-2 text-xs text-emerald-700 dark:text-emerald-300">
|
||||
<ShieldCheck class="h-4 w-4 shrink-0" />
|
||||
<span>{{ salesforceOauthSuccess }}</span>
|
||||
</div>
|
||||
</div>
|
||||
<div v-if="salesforceOauthError && (salesforceAuthMode === 'oauth' || salesforceAuthMode === 'password')" class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 rounded-md border border-destructive/40 bg-destructive/5 px-3 py-2 text-xs text-destructive">
|
||||
{{ salesforceOauthError }}
|
||||
</div>
|
||||
</div>
|
||||
<div v-if="salesforceDeviceError && salesforceAuthMode === 'device' && salesforceDevicePhase !== 'polling' && salesforceDevicePhase !== 'denied'" class="grid grid-cols-4 items-center gap-4">
|
||||
<span />
|
||||
<div class="col-span-3 rounded-md border border-destructive/40 bg-destructive/5 px-3 py-2 text-xs text-destructive">
|
||||
{{ salesforceDeviceError }}
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<!-- MySQL / PostgreSQL: host, port, user, password, database -->
|
||||
<template v-else>
|
||||
<div v-if="form.db_type === 'ignite' || form.db_type === 'ignite3'" class="grid grid-cols-4 items-start gap-4">
|
||||
|
||||
Vendored
+266
@@ -0,0 +1,266 @@
|
||||
// @vitest-environment happy-dom
|
||||
|
||||
import { createApp, defineComponent, h, nextTick, reactive, type App } from "vue";
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import i18n from "@/i18n";
|
||||
import type { ConnectionConfig } from "@/types/database";
|
||||
|
||||
const { store, settings, backend } = vi.hoisted(() => ({
|
||||
store: {
|
||||
connectionGroupOptions: [],
|
||||
newConnectionGroupId: null,
|
||||
selectedConnectionGroupId: null,
|
||||
addConnection: vi.fn(),
|
||||
updateConnection: vi.fn(),
|
||||
connect: vi.fn(),
|
||||
ensureConnected: vi.fn(),
|
||||
addEphemeralConnection: vi.fn(),
|
||||
removeConnection: vi.fn(),
|
||||
startEditing: vi.fn(),
|
||||
stopEditing: vi.fn(),
|
||||
clearConnectionError: vi.fn(),
|
||||
updateConnectionDatabaseInfo: vi.fn(),
|
||||
applyGlobalTimeouts: vi.fn((config) => config),
|
||||
getConfig: vi.fn(),
|
||||
},
|
||||
settings: {
|
||||
editorSettings: { sidebarShowConnectionNotes: false, globalConnectTimeoutSecs: 10, globalQueryTimeoutSecs: 0 },
|
||||
rememberedDatabaseForConnection: vi.fn(() => ""),
|
||||
persistEditorSettings: vi.fn(),
|
||||
updateEditorSettings: vi.fn(),
|
||||
updateEditorSettingsAndPersist: vi.fn(),
|
||||
},
|
||||
backend: {
|
||||
connectDb: vi.fn(),
|
||||
disconnectDb: vi.fn(),
|
||||
testConnectionWithInfo: vi.fn(),
|
||||
listDatabases: vi.fn(),
|
||||
listPlugins: vi.fn(),
|
||||
listJdbcDrivers: vi.fn(),
|
||||
listJdbcMavenBundles: vi.fn(),
|
||||
listJdbcLocalBundles: vi.fn(),
|
||||
listSshConfigHosts: vi.fn(),
|
||||
listInstalledAgentsLocal: vi.fn(),
|
||||
listenAgentInstallProgress: vi.fn(),
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock("@/stores/connectionStore", () => ({ useConnectionStore: () => store, CONNECTION_ATTEMPT_CANCELLED_MESSAGE: "cancelled" }));
|
||||
vi.mock("@/stores/settingsStore", async (original) => ({ ...(await original<typeof import("@/stores/settingsStore")>()), useSettingsStore: () => settings }));
|
||||
vi.mock("@/stores/tunnelProfileStore", () => ({ useTunnelProfileStore: () => ({ profiles: [], profileById: () => undefined, init: vi.fn() }) }));
|
||||
vi.mock("@/lib/backend/api", async (original) => ({ ...(await original<typeof import("@/lib/backend/api")>()), ...backend }));
|
||||
vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
|
||||
vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: vi.fn() }) }));
|
||||
|
||||
vi.mock("@/components/ui/dialog", async () => {
|
||||
const { defineComponent, h } = await import("vue");
|
||||
const passthrough = defineComponent({
|
||||
setup:
|
||||
(_props, { slots }) =>
|
||||
() =>
|
||||
h("div", slots.default?.()),
|
||||
});
|
||||
const Dialog = defineComponent({
|
||||
props: { open: Boolean },
|
||||
emits: ["update:open"],
|
||||
setup:
|
||||
(props, { slots, emit }) =>
|
||||
() =>
|
||||
props.open ? h("section", [h("button", { "data-testid": "dismiss-dialog", onClick: () => emit("update:open", false) }, "Dismiss"), slots.default?.()]) : null,
|
||||
});
|
||||
return { Dialog, DialogContent: passthrough, DialogHeader: passthrough, DialogTitle: passthrough, DialogFooter: passthrough };
|
||||
});
|
||||
vi.mock("@/components/ui/button", async () => {
|
||||
const { defineComponent, h } = await import("vue");
|
||||
return {
|
||||
Button: defineComponent({
|
||||
inheritAttrs: false,
|
||||
setup:
|
||||
(_props, { attrs, slots }) =>
|
||||
() =>
|
||||
h("button", attrs, slots.default?.()),
|
||||
}),
|
||||
};
|
||||
});
|
||||
vi.mock("@/components/ui/input", async () => {
|
||||
const { defineComponent, h } = await import("vue");
|
||||
return {
|
||||
Input: defineComponent({
|
||||
props: ["modelValue"],
|
||||
emits: ["update:modelValue"],
|
||||
setup:
|
||||
(props, { attrs, emit }) =>
|
||||
() =>
|
||||
h("input", { ...attrs, value: props.modelValue, onInput: (event: Event) => emit("update:modelValue", (event.target as HTMLInputElement).value) }),
|
||||
}),
|
||||
};
|
||||
});
|
||||
vi.mock("@/components/ui/PasswordInput.vue", async () => {
|
||||
const { defineComponent, h } = await import("vue");
|
||||
return {
|
||||
default: defineComponent({
|
||||
props: ["modelValue"],
|
||||
setup:
|
||||
(props, { attrs }) =>
|
||||
() =>
|
||||
h("input", { ...attrs, type: "password", value: props.modelValue }),
|
||||
}),
|
||||
};
|
||||
});
|
||||
vi.mock("@/components/ui/tabs", async () => {
|
||||
const { defineComponent, h } = await import("vue");
|
||||
const pass = defineComponent({
|
||||
setup:
|
||||
(_props, { slots }) =>
|
||||
() =>
|
||||
h("div", slots.default?.()),
|
||||
});
|
||||
const TabsContent = defineComponent({
|
||||
props: ["value"],
|
||||
setup:
|
||||
(props, { slots }) =>
|
||||
() =>
|
||||
props.value === "connection" ? h("div", slots.default?.()) : null,
|
||||
});
|
||||
return { Tabs: pass, TabsContent, TabsList: pass, TabsTrigger: pass };
|
||||
});
|
||||
vi.mock("@/components/ui/tooltip", async () => {
|
||||
const { defineComponent, h } = await import("vue");
|
||||
const pass = defineComponent({
|
||||
setup:
|
||||
(_props, { slots }) =>
|
||||
() =>
|
||||
h("span", slots.default?.()),
|
||||
});
|
||||
return { HelpTooltip: pass, Tooltip: pass, TooltipContent: pass, TooltipTrigger: pass };
|
||||
});
|
||||
|
||||
import ConnectionDialog from "@/components/connection/ConnectionDialog.vue";
|
||||
|
||||
const mountedApps: App[] = [];
|
||||
|
||||
function salesforceConnection(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
|
||||
return {
|
||||
id: "sfdc-sandbox",
|
||||
name: "Salesforce sandbox",
|
||||
db_type: "salesforce",
|
||||
driver_profile: "salesforce",
|
||||
driver_label: "Salesforce",
|
||||
host: "https://acme--qas1.sandbox.my.salesforce.com",
|
||||
port: 443,
|
||||
password: "saved-access-token",
|
||||
ssl: true,
|
||||
save_password: true,
|
||||
...overrides,
|
||||
} as ConnectionConfig;
|
||||
}
|
||||
|
||||
async function settle() {
|
||||
for (let i = 0; i < 8; i++) await nextTick();
|
||||
}
|
||||
|
||||
async function mountDialog(config: ConnectionConfig) {
|
||||
const props = reactive({ open: true, editConfig: config });
|
||||
store.getConfig.mockReturnValue(config);
|
||||
const container = document.createElement("div");
|
||||
document.body.append(container);
|
||||
const app = createApp(
|
||||
defineComponent({
|
||||
setup: () => () =>
|
||||
h(ConnectionDialog, {
|
||||
...props,
|
||||
"onUpdate:open": (value: boolean) => {
|
||||
props.open = value;
|
||||
},
|
||||
}),
|
||||
}),
|
||||
);
|
||||
app.use(i18n);
|
||||
mountedApps.push(app);
|
||||
app.mount(container);
|
||||
await settle();
|
||||
return props;
|
||||
}
|
||||
|
||||
function findModeButton(label: string): HTMLButtonElement | undefined {
|
||||
return [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === label) as HTMLButtonElement | undefined;
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
i18n.global.locale.value = "en";
|
||||
for (const fn of Object.values(backend)) fn.mockResolvedValue([]);
|
||||
backend.listenAgentInstallProgress.mockResolvedValue(() => {});
|
||||
store.updateConnection.mockResolvedValue(undefined);
|
||||
store.addConnection.mockResolvedValue(undefined);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
for (const app of mountedApps.splice(0)) app.unmount();
|
||||
document.body.innerHTML = "";
|
||||
});
|
||||
|
||||
describe("ConnectionDialog Salesforce username-password mode", () => {
|
||||
it("switches to password mode and reveals the credential inputs", async () => {
|
||||
await mountDialog(salesforceConnection());
|
||||
|
||||
const passwordTab = findModeButton("Username & Password");
|
||||
expect(passwordTab, "password mode button should exist").toBeTruthy();
|
||||
expect(passwordTab!.disabled, "password mode button should be clickable").toBe(false);
|
||||
|
||||
passwordTab!.click();
|
||||
await settle();
|
||||
|
||||
expect(passwordTab!.getAttribute("aria-pressed")).toBe("true");
|
||||
const username = [...document.querySelectorAll("input")].find((input) => input.getAttribute("placeholder") === "user@example.com");
|
||||
expect(username, "username input should render in password mode").toBeTruthy();
|
||||
expect((username as HTMLInputElement).disabled).toBe(false);
|
||||
const signIn = findModeButton("Sign In");
|
||||
expect(signIn, "sign-in button should render in password mode").toBeTruthy();
|
||||
});
|
||||
|
||||
it("keeps the password mode button enabled while a browser OAuth authorize is not running", async () => {
|
||||
await mountDialog(salesforceConnection({ external_config: { auth: { mode: "oauth", environment: "sandbox", clientId: "consumer-key", authorizedAt: "2026-09-21T00:00:00.000Z" } } } as Partial<ConnectionConfig>));
|
||||
|
||||
const passwordTab = findModeButton("Username & Password");
|
||||
expect(passwordTab).toBeTruthy();
|
||||
expect(passwordTab!.disabled).toBe(false);
|
||||
passwordTab!.click();
|
||||
await settle();
|
||||
expect(passwordTab!.getAttribute("aria-pressed")).toBe("true");
|
||||
});
|
||||
|
||||
it("shows each mode only the guidance that applies to it", async () => {
|
||||
const bodyText = () => document.body.textContent ?? "";
|
||||
|
||||
// Token mode carries no Connected App at all: neither client-ID hint renders,
|
||||
// and Salesforce has no TLS toggle (the driver always speaks HTTPS).
|
||||
await mountDialog(salesforceConnection());
|
||||
expect(bodyText()).not.toContain("The Connected App consumer key.");
|
||||
expect(bodyText()).not.toContain("Create a Connected App in Salesforce Setup");
|
||||
expect(bodyText()).not.toContain("Enable encrypted connection");
|
||||
|
||||
const passwordTab = findModeButton("Username & Password");
|
||||
passwordTab!.click();
|
||||
await settle();
|
||||
expect(bodyText()).toContain("The Connected App consumer key.");
|
||||
expect(bodyText()).toContain("No callback URL needed");
|
||||
expect(bodyText()).not.toContain("Create a Connected App in Salesforce Setup");
|
||||
|
||||
const deviceTab = findModeButton("Device Code");
|
||||
deviceTab!.click();
|
||||
await settle();
|
||||
expect(bodyText()).toContain("If requesting the code fails");
|
||||
expect(bodyText()).not.toContain("No callback URL needed");
|
||||
});
|
||||
|
||||
it("reserves the callback-URL guidance for browser OAuth", async () => {
|
||||
await mountDialog(salesforceConnection({ external_config: { auth: { mode: "oauth", environment: "sandbox", clientId: "consumer-key" } } } as Partial<ConnectionConfig>));
|
||||
await settle();
|
||||
|
||||
const text = document.body.textContent ?? "";
|
||||
expect(text).toContain("Create a Connected App in Salesforce Setup");
|
||||
expect(text).not.toContain("The Connected App consumer key.");
|
||||
expect(text).not.toContain("If requesting the code fails");
|
||||
});
|
||||
});
|
||||
@@ -114,7 +114,7 @@ let initializingPrefillGeneration = 0;
|
||||
let componentUnmounted = false;
|
||||
let shownSessionError = "";
|
||||
|
||||
const sqlConnections = computed(() => store.connections.filter((connection) => !["redis", "mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos"].includes(connection.db_type)));
|
||||
const sqlConnections = computed(() => store.connections.filter((connection) => !["redis", "mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "salesforce"].includes(connection.db_type)));
|
||||
const selectedSourceTableNames = computed(() => sourceTables.value.filter((table) => selectedSourceTables.value.has(table)));
|
||||
const isBatchCompare = computed(() => selectedSourceTableNames.value.length > 1);
|
||||
// Bridge the shared TableMultiSelect `string[]` v-model with the Set-based selection store.
|
||||
|
||||
@@ -84,7 +84,7 @@ const targetSchemas = ref<string[]>([]);
|
||||
const sourceDbVersion = ref<string | null>(null);
|
||||
const targetDbVersion = ref<string | null>(null);
|
||||
|
||||
const sqlConnections = computed(() => store.connections.filter((c: any) => !["mongodb", "redis", "elasticsearch", "easysearch", "meilisearch", "solr", "etcd", "zookeeper", "consul", "mq", "nacos"].includes(c.db_type)));
|
||||
const sqlConnections = computed(() => store.connections.filter((c: any) => !["mongodb", "redis", "elasticsearch", "easysearch", "meilisearch", "solr", "etcd", "zookeeper", "consul", "mq", "nacos", "salesforce"].includes(c.db_type)));
|
||||
|
||||
const sourceConfig = computed(() => store.getConfig(props.sourceConnectionId));
|
||||
const targetConfig = computed(() => store.getConfig(props.targetConnectionId));
|
||||
|
||||
@@ -3471,6 +3471,7 @@ async function saveMcpPolicy(
|
||||
databaseScope: "all" | "selected" | "none";
|
||||
allowedDatabases: string[];
|
||||
databasePolicies: { databaseName: string; readOnly: boolean; allowDangerousSql: boolean }[];
|
||||
allowSalesforceDml: boolean;
|
||||
}[];
|
||||
groupPolicies?: McpGroupPolicy[];
|
||||
queryTimeoutSecs?: number | null;
|
||||
@@ -3659,6 +3660,14 @@ function onMcpGroupExecutionModeChange(groupId: string, mode: McpConnectionExecu
|
||||
void saveMcpPolicy({ groupPolicies });
|
||||
}
|
||||
|
||||
// A connection rule is only worth persisting when it actually changes something: an
|
||||
// explicit execution mode, a narrowed database scope, a per-database override, or the
|
||||
// Salesforce DML opt-in. Rules that merely restate the inherited defaults are dropped so
|
||||
// the stored policy stays readable and keeps following later global changes.
|
||||
function mcpConnectionPolicyIsMeaningful(rule: McpConnectionPolicy): boolean {
|
||||
return rule.executionModeConfigured || rule.databaseScope !== "all" || rule.databasePolicies.length > 0 || rule.allowSalesforceDml;
|
||||
}
|
||||
|
||||
function onMcpConnectionExecutionModeChange(connectionId: string, mode: McpConnectionExecutionMode | "inherit") {
|
||||
if (mode === "high_risk_write" && !window.confirm(t("settings.mcpExecutionModeHighRiskConfirm"))) return;
|
||||
const existing = settingsStore.mcpGlobalPolicy.connectionPolicies.find((item) => item.connectionId === connectionId);
|
||||
@@ -3682,8 +3691,38 @@ function onMcpConnectionExecutionModeChange(connectionId: string, mode: McpConne
|
||||
databaseScope: existing?.databaseScope ?? ("all" as const),
|
||||
allowedDatabases: existing?.allowedDatabases ?? [],
|
||||
databasePolicies: selectedMode.databasePolicies,
|
||||
// Switching a connection to read-only silently revokes the DML opt-in, matching
|
||||
// the backend's ceiling: an agent must never keep a write path it lost.
|
||||
allowSalesforceDml: (existing?.allowSalesforceDml ?? false) && !selectedMode.readOnly,
|
||||
};
|
||||
if (next.executionModeConfigured || next.databaseScope !== "all" || next.databasePolicies.length > 0) rules.push(next);
|
||||
if (mcpConnectionPolicyIsMeaningful(next)) rules.push(next);
|
||||
void saveMcpPolicy({ connectionPolicies: rules });
|
||||
}
|
||||
|
||||
function onMcpConnectionSalesforceDmlChange(connectionId: string, allowed: boolean) {
|
||||
const existing = settingsStore.mcpGlobalPolicy.connectionPolicies.find((item) => item.connectionId === connectionId);
|
||||
if (allowed) {
|
||||
// Read-only is a hard ceiling on the server too, so letting the box stay checked
|
||||
// here would only advertise a write path that every prepare call then refuses.
|
||||
const effectiveMode = mcpEffectiveExecutionMode(mcpInheritedGroupExecutionMode(connectionId), mcpConnectionExecutionMode(connectionId), "inherit");
|
||||
if (effectiveMode === "read_only") {
|
||||
toast(t("settings.mcpConnectionPolicyAllowSalesforceDmlReadOnlyBlocked"), 5000);
|
||||
return;
|
||||
}
|
||||
}
|
||||
const rules = settingsStore.mcpGlobalPolicy.connectionPolicies.filter((item) => item.connectionId !== connectionId);
|
||||
const next: McpConnectionPolicy = {
|
||||
connectionId,
|
||||
readOnly: existing?.readOnly ?? false,
|
||||
allowDangerousSql: existing?.allowDangerousSql ?? false,
|
||||
executionModeConfigured: existing?.executionModeConfigured ?? false,
|
||||
executionModePolicyVersion: existing?.executionModePolicyVersion ?? null,
|
||||
databaseScope: existing?.databaseScope ?? "all",
|
||||
allowedDatabases: existing?.allowedDatabases ?? [],
|
||||
databasePolicies: existing?.databasePolicies ?? [],
|
||||
allowSalesforceDml: allowed,
|
||||
};
|
||||
if (mcpConnectionPolicyIsMeaningful(next)) rules.push(next);
|
||||
void saveMcpPolicy({ connectionPolicies: rules });
|
||||
}
|
||||
|
||||
@@ -3703,7 +3742,7 @@ function onMcpDatabaseExecutionModeChange(connectionId: string, databaseName: st
|
||||
databasePolicies,
|
||||
};
|
||||
const rules = settingsStore.mcpGlobalPolicy.connectionPolicies.filter((item) => item.connectionId !== connectionId);
|
||||
if (next.executionModeConfigured || next.databaseScope !== "all" || next.databasePolicies.length > 0) rules.push(next);
|
||||
if (mcpConnectionPolicyIsMeaningful(next)) rules.push(next);
|
||||
void saveMcpPolicy({ connectionPolicies: rules });
|
||||
}
|
||||
|
||||
@@ -9938,6 +9977,7 @@ LIMIT 100;</pre
|
||||
@update:scope="onMcpResourceScopeChange"
|
||||
@set:group-policy="onMcpGroupExecutionModeChange"
|
||||
@set:connection-policy="onMcpConnectionExecutionModeChange"
|
||||
@set:connection-salesforce-dml="onMcpConnectionSalesforceDmlChange"
|
||||
/>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
@@ -139,7 +139,9 @@ import type { SqlCompletionColumn, SqlCompletionContext, SqlCompletionReferenced
|
||||
const props = defineProps<QueryEditorProps>();
|
||||
|
||||
function sqlBehaviorDialect(): "mysql" | "postgres" | "sqlserver" | undefined {
|
||||
return props.syntaxDialect === "clickhouse" ? props.dialect : (props.syntaxDialect ?? props.dialect);
|
||||
// clickhouse and soql ride the SQL editor but have no matching behavior dialect;
|
||||
// fall back to the connection's dialect (undefined for Salesforce).
|
||||
return props.syntaxDialect === "clickhouse" || props.syntaxDialect === "soql" ? props.dialect : (props.syntaxDialect ?? props.dialect);
|
||||
}
|
||||
|
||||
function queryEditorSelectionLanguage(): "sql" | "text" {
|
||||
|
||||
@@ -9,9 +9,10 @@ import { type ElasticsearchCompletionItem } from "@/lib/elasticsearch/elasticsea
|
||||
import { type MongoCompletionItem } from "@/lib/mongo/mongoCompletion";
|
||||
import { batchColumnSelectionColumnList, batchColumnSelectionInsertReplacement, batchColumnSelectionReplaceTo, isBatchColumnSelectionCompletionActive } from "@/lib/editor/batchColumnSelection";
|
||||
import { type RedisCompletionItem } from "@/lib/redis/redisCompletion";
|
||||
import { type SoqlCompletionItem } from "@/lib/soql/soqlCompletion";
|
||||
import type { SqlCompletionItem } from "@/lib/sql/sqlCompletion";
|
||||
|
||||
export type QueryCompletionItem = SqlCompletionItem | ElasticsearchCompletionItem | RedisCompletionItem | MongoCompletionItem;
|
||||
export type QueryCompletionItem = SqlCompletionItem | ElasticsearchCompletionItem | RedisCompletionItem | MongoCompletionItem | SoqlCompletionItem;
|
||||
|
||||
export interface BatchColumnSelectionActionItem {
|
||||
label: string;
|
||||
|
||||
@@ -25,6 +25,7 @@ import { sqlCompletionContextFromSemantic } from "@/lib/sql/semantic/completion"
|
||||
import { buildSqlSemanticModel } from "@/lib/sql/semantic/model";
|
||||
import { buildElasticsearchCompletionItemsFromContext, elasticsearchCompletionNeedsFields, getElasticsearchCompletionContext, getElasticsearchCompletionResultValidFor, shouldAutoOpenElasticsearchCompletion, type ElasticsearchCompletionField } from "@/lib/elasticsearch/elasticsearchCompletion";
|
||||
import { buildMongoCompletionItemsFromContext, getMongoCompletionContext, getMongoCompletionResultValidFor, mongoCompletionNeedsCollections, mongoCompletionNeedsFields, shouldAutoOpenMongoCompletion } from "@/lib/mongo/mongoCompletion";
|
||||
import { buildSoqlCompletionItems, getSoqlCompletionContext, getSoqlCompletionResultValidFor, resolveSoqlFieldCandidates, resolveSoqlValueField, shouldAutoOpenSoqlCompletion, soqlCompletionNeedsObjects, type SoqlCompletionField, type SoqlCompletionObject } from "@/lib/soql/soqlCompletion";
|
||||
import {
|
||||
buildSqlServerUseDatabaseCompletionItems,
|
||||
mergeSqlCompletionQualifierNames,
|
||||
@@ -361,7 +362,16 @@ export function useQueryEditorCompletion(options: QueryEditorCompletionOptions)
|
||||
}
|
||||
|
||||
function shouldInsertSqlCompletionSpace(): boolean {
|
||||
return props.databaseType !== "mongodb" && props.databaseType !== "redis" && props.databaseType !== "elasticsearch" && props.databaseType !== "easysearch" && props.databaseType !== "meilisearch" && props.databaseType !== "solr" && props.databaseType !== "victoriametrics";
|
||||
return (
|
||||
props.databaseType !== "mongodb" &&
|
||||
props.databaseType !== "redis" &&
|
||||
props.databaseType !== "elasticsearch" &&
|
||||
props.databaseType !== "easysearch" &&
|
||||
props.databaseType !== "meilisearch" &&
|
||||
props.databaseType !== "solr" &&
|
||||
props.databaseType !== "victoriametrics" &&
|
||||
props.databaseType !== "salesforce"
|
||||
);
|
||||
}
|
||||
|
||||
// Snippet expansion normally follows from the item type; a provider can also
|
||||
@@ -591,6 +601,59 @@ export function useQueryEditorCompletion(options: QueryEditorCompletionOptions)
|
||||
};
|
||||
}
|
||||
|
||||
async function provideSoqlCompletions(currentState: import("@codemirror/state").EditorState, position: number, explicit: boolean) {
|
||||
if (!props.connectionId) return null;
|
||||
const epoch = ++completionEpoch;
|
||||
const fullDoc = currentState.doc.toString();
|
||||
if (!explicit && !shouldAutoOpenSoqlCompletion(fullDoc, position)) return null;
|
||||
|
||||
const completionContext = getSoqlCompletionContext(fullDoc, position);
|
||||
if (completionContext.mode === "none") return null;
|
||||
// The Salesforce backend ignores the database parameter for metadata (the whole
|
||||
// org is one synthesized database), so completion must not gate on props.database
|
||||
// being populated — a restored/toolbar-opened tab can carry an empty database
|
||||
// while the connection works fine. Pass it through (possibly "") and let the
|
||||
// store/backend resolve it.
|
||||
const database = props.database ?? "";
|
||||
|
||||
let objects: SoqlCompletionObject[] = [];
|
||||
let fields: SoqlCompletionField[] = [];
|
||||
let valueField: SoqlCompletionField | null = null;
|
||||
|
||||
// Field loader backed by the store (which reads the backend describe cache), so
|
||||
// relationship traversal costs at most one describe per distinct sObject.
|
||||
const loadFields = (objectName: string) => connectionStore.listSoqlCompletionFields(props.connectionId!, database, objectName);
|
||||
|
||||
try {
|
||||
if (soqlCompletionNeedsObjects(completionContext.mode)) {
|
||||
objects = await connectionStore.listSoqlCompletionObjects(props.connectionId, database);
|
||||
}
|
||||
if (completionContext.mode === "field") {
|
||||
fields = await resolveSoqlFieldCandidates(completionContext, loadFields);
|
||||
}
|
||||
if (completionContext.mode === "value") {
|
||||
valueField = await resolveSoqlValueField(completionContext, loadFields);
|
||||
}
|
||||
} catch (error) {
|
||||
// Metadata load failed (offline, describe error, no cache yet): fall back to
|
||||
// keyword/function-only completion. Logged so a persistent empty field list is
|
||||
// diagnosable instead of silently looking like "custom fields are excluded".
|
||||
console.debug("[soql-completion] metadata load failed", error);
|
||||
objects = [];
|
||||
fields = [];
|
||||
valueField = null;
|
||||
}
|
||||
if (epoch !== completionEpoch) return null;
|
||||
|
||||
const items = buildSoqlCompletionItems(completionContext, { objects, fields, valueField });
|
||||
if (items.length === 0) return null;
|
||||
return {
|
||||
from: completionContext.from,
|
||||
options: items.map((item) => completionOptionForItem(item)),
|
||||
validFor: getSoqlCompletionResultValidFor(completionContext),
|
||||
};
|
||||
}
|
||||
|
||||
async function provideSqlCompletions(context: CompletionContext) {
|
||||
const currentState = context.state;
|
||||
const position = context.pos;
|
||||
@@ -612,6 +675,9 @@ export function useQueryEditorCompletion(options: QueryEditorCompletionOptions)
|
||||
return provideRedisCompletions(currentState, position, explicit);
|
||||
}
|
||||
if (props.databaseType === "victoriametrics") return null;
|
||||
if (props.databaseType === "salesforce") {
|
||||
return provideSoqlCompletions(currentState, position, explicit);
|
||||
}
|
||||
const hasDatabase = props.database != null;
|
||||
const sequenceLiteralContext = getPostgresSequenceLiteralCompletionContext(fullDoc, position, props.databaseType);
|
||||
const databaseLinkContext = oracleDatabaseLinkCompletionContext(fullDoc, position, props.databaseType);
|
||||
|
||||
@@ -195,7 +195,7 @@ export function useQueryEditorDiagnostics(options: QueryEditorDiagnosticsOptions
|
||||
}
|
||||
|
||||
function shouldSkipSqlSemanticDiagnostics() {
|
||||
return props.databaseType === "victoriametrics" || (props.databaseType !== "redis" && props.databaseType !== "mongodb" && !settingsStore.editorSettings.sqlSemanticDiagnosticsEnabled);
|
||||
return props.databaseType === "victoriametrics" || props.databaseType === "salesforce" || (props.databaseType !== "redis" && props.databaseType !== "mongodb" && !settingsStore.editorSettings.sqlSemanticDiagnosticsEnabled);
|
||||
}
|
||||
|
||||
function rangesOverlap(left: { from: number; to: number }, right: { from: number; to: number }): boolean {
|
||||
@@ -337,7 +337,7 @@ export function useQueryEditorDiagnostics(options: QueryEditorDiagnosticsOptions
|
||||
setSemanticDiagnostics([]);
|
||||
return;
|
||||
}
|
||||
if (props.databaseType === "elasticsearch" || props.databaseType === "easysearch" || props.databaseType === "meilisearch" || props.databaseType === "solr" || props.databaseType === "victoriametrics") {
|
||||
if (props.databaseType === "elasticsearch" || props.databaseType === "easysearch" || props.databaseType === "meilisearch" || props.databaseType === "solr" || props.databaseType === "victoriametrics" || props.databaseType === "salesforce") {
|
||||
setSemanticDiagnostics([]);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -115,7 +115,7 @@ const exportElapsedText = computed(() => {
|
||||
return formatDataTransferDuration((exportFinishedAt.value ?? currentTime.value) - exportStartedAt.value);
|
||||
});
|
||||
|
||||
const sqlConnections = computed(() => store.connections.filter((c) => !["redis", "mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos"].includes(c.db_type)));
|
||||
const sqlConnections = computed(() => store.connections.filter((c) => !["redis", "mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "salesforce"].includes(c.db_type)));
|
||||
|
||||
const canExport = computed(() => {
|
||||
const hasContent = includeStructure.value || includeData.value || includeObjects.value;
|
||||
|
||||
@@ -119,6 +119,8 @@ import {
|
||||
hiveTablePropertiesIndicateTransactional,
|
||||
isClickHouseExistingRowReadonlyColumn,
|
||||
isHiddenGridColumn,
|
||||
isSalesforceExistingRowReadonlyColumn,
|
||||
isSalesforceNewRowReadonlyColumn,
|
||||
isTdengineExistingRowReadonlyColumn,
|
||||
shouldIncludeSyntheticRowId,
|
||||
} from "@/lib/table/tableEditing";
|
||||
@@ -369,6 +371,7 @@ import { useDataGridColumnFormatter } from "@/composables/useDataGridColumnForma
|
||||
import { useDataGridTableMetadataLoaders } from "@/composables/useDataGridTableMetadataLoaders";
|
||||
import { DATA_GRID_SERVER_COLUMN_FILTER_LIMIT, useDataGridColumnFilters } from "@/composables/useDataGridColumnFilters";
|
||||
import { useDataGridLargeValues } from "@/composables/useDataGridLargeValues";
|
||||
import { useSalesforceSaveConfirmation } from "@/composables/useSalesforceSaveConfirmation";
|
||||
|
||||
const SqlPreviewPanel = defineAsyncComponent(() => import("@/components/editor/SqlPreviewPanel.vue"));
|
||||
const ImagePreviewDialog = defineAsyncComponent(() => import("@/components/grid/ImagePreviewDialog.vue"));
|
||||
@@ -3797,6 +3800,57 @@ async function refreshSavedRows(request: { dirtyRows: ReadonlyMap<number, Readon
|
||||
return true;
|
||||
}
|
||||
|
||||
// Salesforce applies one REST call per record with no transaction, so every grid
|
||||
// save is reviewed here first. The identity lines are advisory only — Salesforce
|
||||
// enforces the real object/field permissions, and a failed identity lookup just
|
||||
// omits the line rather than blocking the write.
|
||||
const {
|
||||
open: salesforceSaveConfirmOpen,
|
||||
updates: salesforceSaveConfirmUpdates,
|
||||
inserts: salesforceSaveConfirmInserts,
|
||||
deletes: salesforceSaveConfirmDeletes,
|
||||
total: salesforceSaveConfirmTotal,
|
||||
targetLabel: salesforceSaveConfirmTarget,
|
||||
statements: salesforceSaveConfirmStatements,
|
||||
request: requestSalesforceSaveConfirmation,
|
||||
confirm: confirmSalesforceSave,
|
||||
} = useSalesforceSaveConfirmation();
|
||||
const isSalesforceGrid = computed(() => resolvedDatabaseType.value === "salesforce");
|
||||
const salesforceIdentity = computed(() => (isSalesforceGrid.value && props.connectionId ? connectionStore.salesforceCurrentUser(props.connectionId) : null));
|
||||
const salesforceIdentityLabel = computed(() => {
|
||||
const identity = salesforceIdentity.value;
|
||||
if (!identity) return "";
|
||||
return identity.username || identity.name || identity.email;
|
||||
});
|
||||
const salesforceSaveConfirmSummary = computed(() => {
|
||||
const parts: string[] = [];
|
||||
if (salesforceSaveConfirmUpdates.value > 0) parts.push(t("grid.salesforceSaveUpdates", { count: salesforceSaveConfirmUpdates.value }));
|
||||
if (salesforceSaveConfirmInserts.value > 0) parts.push(t("grid.salesforceSaveInserts", { count: salesforceSaveConfirmInserts.value }));
|
||||
if (salesforceSaveConfirmDeletes.value > 0) parts.push(t("grid.salesforceSaveDeletes", { count: salesforceSaveConfirmDeletes.value }));
|
||||
return parts.join(" · ");
|
||||
});
|
||||
// The save dialog names the profile alongside the user: writability comes from
|
||||
// the profile's FLS plus record sharing, not from the admin flag alone.
|
||||
const salesforceIdentityProfile = computed(() => {
|
||||
const profileName = salesforceIdentity.value?.profileName;
|
||||
return profileName ? t("grid.salesforceSaveProfile", { name: profileName }) : t("toolbar.salesforceIdentityUnknownProfile");
|
||||
});
|
||||
const salesforceSaveConfirmDetails = computed(() => {
|
||||
const lines = [salesforceSaveConfirmSummary.value, t("grid.salesforceSaveTarget", { object: salesforceSaveConfirmTarget.value || t("grid.salesforceSaveUnknownObject") })];
|
||||
if (salesforceIdentity.value) {
|
||||
const identity = { user: salesforceIdentityLabel.value, profile: salesforceIdentityProfile.value };
|
||||
if (salesforceIdentity.value.isAdmin === true) lines.push(t("grid.salesforceSaveAdminIdentity", identity));
|
||||
else if (salesforceIdentity.value.isAdmin === false) lines.push(t("grid.salesforceSaveNonAdminIdentity", identity));
|
||||
else lines.push(t("grid.salesforceSaveUnknownRights", identity));
|
||||
}
|
||||
return lines.filter((line) => !!line).join("\n");
|
||||
});
|
||||
const salesforceSaveConfirmSql = computed(() => salesforceSaveConfirmStatements.value.join("\n"));
|
||||
watch(salesforceSaveConfirmOpen, (isOpen) => {
|
||||
if (!isOpen || !props.connectionId) return;
|
||||
void connectionStore.loadSalesforceCurrentUser(props.connectionId);
|
||||
});
|
||||
|
||||
const editor = useDataGridEditor({
|
||||
result: computed(() => props.result),
|
||||
editable: computed(() => props.editable),
|
||||
@@ -3821,6 +3875,8 @@ const editor = useDataGridEditor({
|
||||
rowStatusFilter,
|
||||
dataGridQuickEntryEnabled: computed(() => settingsStore.editorSettings.dataGridQuickEntry),
|
||||
confirmDangerousRowDeletion: computed(() => settingsStore.editorSettings.confirmDangerousSqlExecution),
|
||||
// Only Salesforce opts in: its writes cannot be rolled back once issued.
|
||||
confirmSaveRequest: computed(() => (isSalesforceGrid.value ? requestSalesforceSaveConfirmation : undefined)),
|
||||
includeDatabaseNameInSaveSql: computed(() => settingsStore.editorSettings.generateSqlIncludeDatabaseName),
|
||||
initialEditColumn: firstVisibleColumnIndex,
|
||||
cellEditorText: cellEditorTextForValue,
|
||||
@@ -4018,10 +4074,14 @@ function canEditCellItem(item: RowItem | undefined, columnIndex: number): boolea
|
||||
if (isSavingNewRow(item)) return false;
|
||||
const column = props.result.columns[columnIndex] ?? "";
|
||||
if (customReadonlyColumns.value.has(column.toLowerCase())) return false;
|
||||
if (!item?.isNew && !item?.isDraft) {
|
||||
const sourceColumn = props.sourceColumns?.[columnIndex] ?? column;
|
||||
const sourceColumn = props.sourceColumns?.[columnIndex] ?? column;
|
||||
if (item?.isNew || item?.isDraft) {
|
||||
// A new Salesforce record cannot carry non-createable fields (Id, CreatedDate, …).
|
||||
if (isSalesforceNewRowReadonlyColumn(props.databaseType, sourceColumn, props.tableMeta?.columns ?? [])) return false;
|
||||
} else {
|
||||
if (isClickHouseExistingRowReadonlyColumn(props.databaseType, sourceColumn, props.tableMeta?.primaryKeys ?? [], props.tableMeta?.columns ?? [])) return false;
|
||||
if (isTdengineExistingRowReadonlyColumn(props.databaseType, column, props.tableMeta?.columns ?? [])) return false;
|
||||
if (isSalesforceExistingRowReadonlyColumn(props.databaseType, sourceColumn, props.tableMeta?.primaryKeys ?? [], props.tableMeta?.columns ?? [])) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@@ -14211,6 +14271,18 @@ useUpdateBlocker(() => (hasPendingChanges.value || hasPendingDataEditorDraft.val
|
||||
:close-on-confirm="false"
|
||||
@confirm="confirmDropAllMongoIndexes"
|
||||
/>
|
||||
<!-- Salesforce applies each record with its own REST call and cannot roll back, so the
|
||||
save is reviewed here first. Cancel (or closing) denies it and keeps the edits staged. -->
|
||||
<DangerConfirmDialog
|
||||
v-model:open="salesforceSaveConfirmOpen"
|
||||
:title="t('grid.salesforceSaveConfirmTitle')"
|
||||
:message="t('grid.salesforceSaveConfirmMessage', { count: salesforceSaveConfirmTotal })"
|
||||
:details-text="salesforceSaveConfirmDetails"
|
||||
:sql="salesforceSaveConfirmSql"
|
||||
:confirm-label="t('grid.salesforceSaveConfirm')"
|
||||
:close-on-confirm="false"
|
||||
@confirm="confirmSalesforceSave"
|
||||
/>
|
||||
<ImagePreviewDialog v-if="imagePreviewMounted" v-model:open="imagePreviewOpen" :src="imagePreviewSrc" :title="imagePreviewTitle" />
|
||||
<component v-if="previewDialogOpen && previewDialogConfig" :is="previewDialogConfig.component" v-model:open="previewDialogOpen" v-bind="previewDialogConfig.props" />
|
||||
<ExportProgressDialog
|
||||
|
||||
@@ -123,6 +123,7 @@ const assetIcons: Record<string, string> = {
|
||||
jdbcx: "jdbcx",
|
||||
mqtt: "mqtt",
|
||||
dolt: "dolt",
|
||||
salesforce: "salesforce",
|
||||
};
|
||||
|
||||
const normalizedType = computed(() => (props.dbType || "").toLowerCase().replace(/[\s-]+/g, "_"));
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
<script setup lang="ts">
|
||||
import { computed, nextTick, onUnmounted, ref, watch, watchEffect } from "vue";
|
||||
import { useI18n } from "vue-i18n";
|
||||
import { Play, CirclePlay, Loader2, Square, Database, Check, Table2, AlignLeft, GitBranch, Save, FolderOpen, X, Shield, Download, RotateCcw, AlertTriangle, ClipboardPaste, Minimize2, SpellCheck2, Layers, MoreHorizontal, BetweenVerticalStart, Eye, WrapText, RefreshCw } from "@lucide/vue";
|
||||
import { Play, CirclePlay, Loader2, Square, Database, Check, Table2, AlignLeft, GitBranch, Save, FolderOpen, X, Shield, Download, RotateCcw, AlertTriangle, ClipboardPaste, Minimize2, SpellCheck2, Layers, MoreHorizontal, BetweenVerticalStart, Eye, WrapText, RefreshCw, UserRound } from "@lucide/vue";
|
||||
import { supportsInsertValueHints } from "@/lib/editor/codemirrorInsertValueHints";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { SearchableSelect } from "@/components/ui/searchable-select";
|
||||
@@ -215,6 +215,38 @@ const showConnectionProductionBadge = computed(() => activeProductionContext.val
|
||||
const showDatabaseProductionBadge = computed(() => activeProductionContext.value.reason === "database");
|
||||
const activeConnectionValue = computed(() => props.activeConnection?.id || "");
|
||||
const activeSchemaValue = computed(() => props.activeTab.schema || "");
|
||||
// Salesforce identity badge. A Salesforce tab talks to one live org and every grid
|
||||
// save is a real REST write, so the signed-in user stays visible next to the
|
||||
// connection controls. Advisory only: Salesforce enforces the actual permissions.
|
||||
const isSalesforceTab = computed(() => props.activeConnection?.db_type === "salesforce");
|
||||
const salesforceIdentity = computed(() => (props.activeConnection ? connectionStore.salesforceCurrentUser(props.activeConnection.id) : null));
|
||||
const salesforceIdentityLabel = computed(() => {
|
||||
const identity = salesforceIdentity.value;
|
||||
if (!identity) return "";
|
||||
const user = identity.username || identity.name || identity.email;
|
||||
const org = identity.orgName || identity.organizationId;
|
||||
if (user && org) return `${user} @ ${org}`;
|
||||
return user || org;
|
||||
});
|
||||
const salesforceIdentityTooltip = computed(() => {
|
||||
const identity = salesforceIdentity.value;
|
||||
if (!identity) return "";
|
||||
const lines = [identity.name || identity.username || identity.email, identity.profileName || t("toolbar.salesforceIdentityUnknownProfile")];
|
||||
if (identity.isAdmin === true) lines.push(t("toolbar.salesforceIdentityAdmin"));
|
||||
else if (identity.isAdmin === false) lines.push(t("toolbar.salesforceIdentityNonAdmin"));
|
||||
else lines.push(t("toolbar.salesforceIdentityUnknownRights"));
|
||||
return lines.filter((line) => !!line).join("\n");
|
||||
});
|
||||
watch(
|
||||
() => [isSalesforceTab.value, props.activeConnection?.id ?? "", connectionStore.connectedIds.has(props.activeConnection?.id ?? "")] as const,
|
||||
([salesforce, connectionId, connected]) => {
|
||||
// Never connect on a tab switch: only resolve the identity once the user has
|
||||
// established the connection themselves. A failed lookup hides the badge.
|
||||
if (!salesforce || !connected || !connectionId) return;
|
||||
void connectionStore.loadSalesforceCurrentUser(connectionId);
|
||||
},
|
||||
{ immediate: true },
|
||||
);
|
||||
const supportsExplain = computed(() => {
|
||||
const dbType = props.activeConnection?.db_type;
|
||||
return (
|
||||
@@ -233,7 +265,8 @@ const supportsExplain = computed(() => {
|
||||
dbType !== "consul" &&
|
||||
dbType !== "mq" &&
|
||||
dbType !== "nacos" &&
|
||||
dbType !== "victoriametrics"
|
||||
dbType !== "victoriametrics" &&
|
||||
dbType !== "salesforce"
|
||||
);
|
||||
});
|
||||
const isSingleDb = computed(() => isSingleDatabase(props.activeConnection?.db_type));
|
||||
@@ -285,7 +318,7 @@ const sqlSemanticDiagnosticsEnabled = computed(() => settingsStore.editorSetting
|
||||
const sqlSemanticDiagnosticsToggleTooltip = computed(() => (sqlSemanticDiagnosticsEnabled.value ? t("toolbar.sqlSemanticDiagnosticsToggleOn") : t("toolbar.sqlSemanticDiagnosticsToggleOff")));
|
||||
const supportsSqlSemanticDiagnosticsToggle = computed(() => {
|
||||
const dbType = props.activeConnection?.db_type;
|
||||
return dbType !== "redis" && dbType !== "victoriametrics";
|
||||
return dbType !== "redis" && dbType !== "victoriametrics" && dbType !== "salesforce";
|
||||
});
|
||||
function toggleSqlSemanticDiagnostics() {
|
||||
settingsStore.updateEditorSettings({
|
||||
@@ -926,6 +959,11 @@ async function changeCatalog(selectedCatalog: string) {
|
||||
<Table2 class="h-3.5 w-3.5 shrink-0" />
|
||||
<span class="truncate">{{ activeTab.tableMeta.columns.length }} {{ t("tree.columns") }}</span>
|
||||
</div>
|
||||
<div v-if="salesforceIdentity" data-testid="salesforce-identity-badge" class="ml-2 inline-flex max-w-[20rem] shrink-0 items-center gap-1 rounded border border-border bg-muted/30 px-2 py-0.5 font-medium text-muted-foreground" :title="salesforceIdentityTooltip">
|
||||
<Shield v-if="salesforceIdentity.isAdmin === true" class="h-3.5 w-3.5 shrink-0 text-amber-600 dark:text-amber-400" />
|
||||
<UserRound v-else class="h-3.5 w-3.5 shrink-0" />
|
||||
<span class="truncate">{{ salesforceIdentityLabel }}</span>
|
||||
</div>
|
||||
</div>
|
||||
<div v-if="autoCommitTxnRolledBack" data-auto-commit-txn-rolled-back class="flex items-center gap-2 px-3 py-1 text-xs bg-amber-500/10 text-amber-700 dark:text-amber-300 border-b border-amber-500/20">
|
||||
<AlertTriangle class="h-3.5 w-3.5 shrink-0" />
|
||||
|
||||
@@ -89,6 +89,7 @@ function policyFor(connectionId: string): McpConnectionPolicy {
|
||||
databaseScope: "all",
|
||||
allowedDatabases: [],
|
||||
databasePolicies: [],
|
||||
allowSalesforceDml: false,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
@@ -37,7 +37,7 @@ const props = withDefaults(
|
||||
allowedGroupIds: readonly string[];
|
||||
allowedConnectionIds: readonly string[] | null;
|
||||
groupPolicies?: readonly { groupId: string; readOnly: boolean; allowDangerousSql: boolean }[];
|
||||
connectionPolicies?: readonly { connectionId: string; readOnly: boolean; allowDangerousSql: boolean; executionModeConfigured?: boolean }[];
|
||||
connectionPolicies?: readonly { connectionId: string; readOnly: boolean; allowDangerousSql: boolean; executionModeConfigured?: boolean; allowSalesforceDml?: boolean }[];
|
||||
disabled?: boolean;
|
||||
busy?: boolean;
|
||||
}>(),
|
||||
@@ -48,6 +48,7 @@ const emit = defineEmits<{
|
||||
"update:scope": [value: { allowedGroupIds: string[]; allowedConnectionIds: string[] | null }];
|
||||
"set:group-policy": [groupId: string, mode: ExecutionMode | "inherit"];
|
||||
"set:connection-policy": [connectionId: string, mode: ExecutionMode | "inherit"];
|
||||
"set:connection-salesforce-dml": [connectionId: string, allowed: boolean];
|
||||
}>();
|
||||
|
||||
const { t } = useI18n();
|
||||
@@ -264,6 +265,18 @@ function groupPolicyMode(groupId: string): ExecutionMode | "inherit" {
|
||||
function connectionPolicyMode(connectionId: string): ExecutionMode | "inherit" {
|
||||
return policyMode(props.connectionPolicies?.find((policy) => policy.connectionId === connectionId));
|
||||
}
|
||||
|
||||
// Salesforce writes are the one permission that cannot be expressed as an execution
|
||||
// mode: SOQL has no write verb, so a DML toggle is the only gate an agent can be given.
|
||||
// It is per-connection because it is per-org, and it stays hidden for every other driver.
|
||||
function isSalesforceConnection(node: ResourceNode): boolean {
|
||||
return node.type === "connection" && node.connection.db_type === "salesforce";
|
||||
}
|
||||
|
||||
function connectionAllowsSalesforceDml(connectionId: string): boolean {
|
||||
const policy = props.connectionPolicies?.find((item) => item.connectionId === connectionId);
|
||||
return policy?.allowSalesforceDml === true && policy.readOnly !== true;
|
||||
}
|
||||
</script>
|
||||
|
||||
<template>
|
||||
@@ -349,6 +362,23 @@ function connectionPolicyMode(connectionId: string): ExecutionMode | "inherit" {
|
||||
<SelectItem value="high_risk_write">{{ t("settings.mcpConnectionPolicyHighRiskWrite") }}</SelectItem>
|
||||
</SelectContent>
|
||||
</Select>
|
||||
<label
|
||||
v-if="isSalesforceConnection(node) && (explicitConnectionIds.has(node.id) || Boolean(selectedAncestor(node)))"
|
||||
class="flex h-7 shrink-0 cursor-pointer items-center gap-1 rounded border bg-background px-1.5 text-[11px]"
|
||||
:class="connectionAllowsSalesforceDml(node.id) ? 'border-primary/50 text-foreground' : 'text-muted-foreground'"
|
||||
:title="t('settings.mcpConnectionPolicyAllowSalesforceDmlHint')"
|
||||
>
|
||||
<input
|
||||
type="checkbox"
|
||||
class="size-3"
|
||||
:checked="connectionAllowsSalesforceDml(node.id)"
|
||||
:disabled="disabled || busy"
|
||||
:aria-label="t('settings.mcpConnectionPolicyAllowSalesforceDml')"
|
||||
@click.stop
|
||||
@change="emit('set:connection-salesforce-dml', node.id, ($event.target as HTMLInputElement).checked)"
|
||||
/>
|
||||
{{ t("settings.mcpConnectionPolicyAllowSalesforceDml") }}
|
||||
</label>
|
||||
<Badge v-if="selectedAncestor(node)" variant="secondary" class="shrink-0 rounded font-normal">{{ t("settings.mcpResourceScopeInherited", { group: groupLabel(selectedAncestor(node)!) }) }}</Badge>
|
||||
<Badge v-else-if="node.type === 'group' && selectedGroupIds.has(node.id)" variant="outline" class="shrink-0 rounded font-normal">{{ t("settings.mcpResourceScopeDynamic") }}</Badge>
|
||||
<Badge v-else-if="node.type === 'group' && groupHasSelectedDescendant(node)" variant="secondary" class="shrink-0 rounded font-normal">{{ t("settings.mcpResourceScopePartial") }}</Badge>
|
||||
|
||||
@@ -90,6 +90,7 @@ function emptyPolicy(connectionId: string, scope: McpConnectionPolicy["databaseS
|
||||
databaseScope: scope,
|
||||
allowedDatabases: [],
|
||||
databasePolicies: [],
|
||||
allowSalesforceDml: false,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
+69
-1
@@ -1,7 +1,7 @@
|
||||
// @vitest-environment happy-dom
|
||||
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { dispatch, findOne, mountComponent } from "@/components/grid/__tests__/vueHostHarness";
|
||||
import { dispatch, findAll, findOne, mountComponent } from "@/components/grid/__tests__/vueHostHarness";
|
||||
import type { ConnectionConfig, SidebarLayout } from "@/types/database";
|
||||
|
||||
vi.mock("vue-i18n", () => ({
|
||||
@@ -44,6 +44,12 @@ function connection(id: string): ConnectionConfig {
|
||||
};
|
||||
}
|
||||
|
||||
const DML_LABEL = "settings.mcpConnectionPolicyAllowSalesforceDml";
|
||||
|
||||
function salesforceDmlCheckboxes(root: ReturnType<typeof mountComponent>["root"]) {
|
||||
return findAll(root, (node) => node.type === "input" && node.props["aria-label"] === DML_LABEL);
|
||||
}
|
||||
|
||||
const layout: SidebarLayout = {
|
||||
groups: [{ id: "g1", name: "Group 1", collapsed: false }],
|
||||
order: [
|
||||
@@ -169,3 +175,65 @@ describe("McpResourceScopePicker", () => {
|
||||
expect(update).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe("McpResourceScopePicker Salesforce DML opt-in", () => {
|
||||
const sfdc = { ...connection("c2"), db_type: "salesforce" } as unknown as ConnectionConfig;
|
||||
|
||||
function mountWithSalesforce(props: Record<string, unknown> = {}) {
|
||||
const setDml = vi.fn();
|
||||
const mounted = mountComponent(McpResourceScopePicker, {
|
||||
layout,
|
||||
connections: [connection("c1"), sfdc],
|
||||
allowedGroupIds: [],
|
||||
allowedConnectionIds: ["c1", "c2"],
|
||||
"onSet:connection-salesforce-dml": setDml,
|
||||
...props,
|
||||
});
|
||||
return { mounted, setDml };
|
||||
}
|
||||
|
||||
it("offers the write opt-in only on Salesforce connections", () => {
|
||||
const { mounted } = mountWithSalesforce();
|
||||
|
||||
const checkboxes = salesforceDmlCheckboxes(mounted.root);
|
||||
expect(checkboxes).toHaveLength(1);
|
||||
expect(checkboxes[0].props.checked).toBe(false);
|
||||
});
|
||||
|
||||
it("hides the opt-in until the connection is inside the exposed scope", async () => {
|
||||
const { mounted } = mountWithSalesforce({ allowedConnectionIds: ["c1"] });
|
||||
expect(salesforceDmlCheckboxes(mounted.root)).toHaveLength(0);
|
||||
|
||||
await mounted.setProps({ allowedConnectionIds: ["c1", "c2"] });
|
||||
expect(salesforceDmlCheckboxes(mounted.root)).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("emits the connection id and the requested state", () => {
|
||||
const { mounted, setDml } = mountWithSalesforce();
|
||||
|
||||
dispatch(salesforceDmlCheckboxes(mounted.root)[0], "change", { target: { checked: true } });
|
||||
|
||||
expect(setDml).toHaveBeenCalledWith("c2", true);
|
||||
});
|
||||
|
||||
it("shows a persisted opt-in as checked and a read-only rule as off", () => {
|
||||
const optedIn = mountWithSalesforce({
|
||||
connectionPolicies: [{ connectionId: "c2", readOnly: false, allowDangerousSql: false, allowSalesforceDml: true }],
|
||||
});
|
||||
expect(salesforceDmlCheckboxes(optedIn.mounted.root)[0].props.checked).toBe(true);
|
||||
|
||||
// Read-only is a hard ceiling server-side, so the switch must not look enabled here.
|
||||
const readOnly = mountWithSalesforce({
|
||||
connectionPolicies: [{ connectionId: "c2", readOnly: true, allowDangerousSql: false, allowSalesforceDml: true }],
|
||||
});
|
||||
expect(salesforceDmlCheckboxes(readOnly.mounted.root)[0].props.checked).toBe(false);
|
||||
});
|
||||
|
||||
it("does not emit while the policy controls are disabled", () => {
|
||||
const { mounted, setDml } = mountWithSalesforce({ disabled: true });
|
||||
|
||||
dispatch(salesforceDmlCheckboxes(mounted.root)[0], "change", { target: { checked: true } });
|
||||
|
||||
expect(setDml).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -4689,7 +4689,7 @@ const canOpenSqlFileExecution = computed(() => {
|
||||
const canExportAllDatabases = computed(() => {
|
||||
if (activeNode.value.type !== "connection" || !activeNode.value.connectionId) return false;
|
||||
const dbType = connectionStore.getConfig(activeNode.value.connectionId)?.db_type;
|
||||
return !["redis", "mongodb", "dynamodb", "elasticsearch", "easysearch", "solr", "meilisearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "plugin"].includes(dbType || "");
|
||||
return !["redis", "mongodb", "dynamodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "plugin", "salesforce"].includes(dbType || "");
|
||||
});
|
||||
|
||||
const canOpenScheduledBackups = computed(() => {
|
||||
|
||||
@@ -169,7 +169,7 @@ function resetPerFileState() {
|
||||
currentFileName.value = "";
|
||||
}
|
||||
|
||||
const sqlConnections = computed(() => store.connections.filter((c) => !["redis", "mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos"].includes(c.db_type)));
|
||||
const sqlConnections = computed(() => store.connections.filter((c) => !["redis", "mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "salesforce"].includes(c.db_type)));
|
||||
// Mirrors the core executor gate (`relational_constraint_bypass_kind` in
|
||||
// sql_file_import.rs): MySQL-family types use the session-scoped
|
||||
// FOREIGN_KEY_CHECKS toggle, PostgreSQL-family types use DISABLE/ENABLE
|
||||
|
||||
Reference in new issue
Block a user