@deepnote/database-integrations 1.0.0

package/dist/index.js

@@ -0,0 +1,696 @@
+import buildUrl from "build-url-ts";
+import { z } from "zod";
+
+//#region src/sql-integration-auth-methods.ts
+const AwsAuthMethods = {
+	AccessKeys: "access-keys",
+	IamRole: "iam-role"
+};
+const SnowflakeAuthMethods = {
+	AzureAd: "azure",
+	KeyPair: "key-pair",
+	ServiceAccountKeyPair: "service-account-key-pair",
+	NativeSnowflake: "snowflake",
+	Okta: "okta",
+	Password: "password"
+};
+const BigQueryAuthMethods = {
+	ServiceAccount: "service-account",
+	GoogleOauth: "google-oauth"
+};
+const DatabaseAuthMethods = {
+	UsernameAndPassword: "username-and-password",
+	IndividualCredentials: "individual-credentials"
+};
+const federatedAuthMethods = [
+	SnowflakeAuthMethods.Okta,
+	SnowflakeAuthMethods.NativeSnowflake,
+	SnowflakeAuthMethods.AzureAd,
+	SnowflakeAuthMethods.KeyPair,
+	BigQueryAuthMethods.GoogleOauth,
+	DatabaseAuthMethods.IndividualCredentials
+];
+function isFederatedAuthMethod(authMethod) {
+	return federatedAuthMethods.includes(authMethod);
+}
+function isFederatedAuthMetadata(metadata) {
+	return isFederatedAuthMethod(metadata.authMethod);
+}
+
+//#endregion
+//#region src/snowflake-integration-env-vars.ts
+function getSnowflakeSqlAlchemyInput(metadata, params) {
+	if (isFederatedAuthMetadata(metadata)) return null;
+	const { username, accountName, database, authMethod } = metadata;
+	if (authMethod === SnowflakeAuthMethods.ServiceAccountKeyPair) {
+		const url$1 = buildUrl(`snowflake://${encodeURIComponent(username)}@${encodeURIComponent(accountName)}`, {
+			path: database,
+			queryParams: {
+				...createBaseQueryParams(metadata, params.snowflakePartnerIdentifier),
+				authenticator: "snowflake_jwt"
+			}
+		});
+		if (!url$1) throw new Error("getSnowflakeEnvVar URL must be defined");
+		return createSqlAlchemyInputFromUrl(url$1, {
+			privateKey: metadata.privateKey,
+			password: metadata.privateKeyPassphrase,
+			username: metadata.username
+		});
+	}
+	const url = buildUrl(`snowflake://${encodeURIComponent(username)}:${encodeURIComponent(metadata.password)}@${encodeURIComponent(accountName)}`, {
+		path: database,
+		queryParams: { ...createBaseQueryParams(metadata, params.snowflakePartnerIdentifier) }
+	});
+	if (!url) throw new Error("getSnowflakeEnvVar URL must be defined");
+	return createSqlAlchemyInputFromUrl(url);
+}
+function createBaseQueryParams(metadata, snowflakePartnerIdentifier) {
+	return {
+		warehouse: metadata.warehouse,
+		role: metadata.role,
+		application: snowflakePartnerIdentifier
+	};
+}
+function createSqlAlchemyInputFromUrl(url, keyPair) {
+	return {
+		url,
+		params: keyPair ? {
+			snowflake_private_key: Buffer.from(keyPair.privateKey).toString("base64"),
+			snowflake_private_key_passphrase: keyPair.password || void 0
+		} : {},
+		param_style: "pyformat"
+	};
+}
+
+//#endregion
+//#region src/database-integration-env-vars.ts
+function getIntegrationListEnv(sqlIntegrations, params) {
+	const envVars = [];
+	const errors = [];
+	sqlIntegrations.forEach((integration) => {
+		const namePrefix = convertToEnvironmentVariableName(integration.name);
+		const envVarsForThisIntegration = Object.entries(integration.metadata).map(([key, rawValue]) => {
+			const name = `${namePrefix}_${key.toUpperCase()}`;
+			const value = String(rawValue);
+			if (integration.type === "mongodb" && integration.metadata.sslEnabled && key === "connection_string") return {
+				name,
+				value: addSslOptionsToMongoConnectionString(params.projectRootDirectory, value, integration.id, integration.metadata)
+			};
+			return {
+				name,
+				value
+			};
+		});
+		if (integration.type !== "mongodb") try {
+			const envVar = getEnvVarForSqlCells(integration, params);
+			if (envVar) envVarsForThisIntegration.push(envVar);
+		} catch (error) {
+			errors.push(error);
+		}
+		envVars.push(...envVarsForThisIntegration.filter((envVar) => !!envVar.name));
+	});
+	return {
+		envVars,
+		errors
+	};
+}
+const duckDbEnvVar = {
+	url: `deepnote+duckdb:///:memory:`,
+	params: {},
+	param_style: "qmark"
+};
+function addSslOptionsToMongoConnectionString(projectRoot, connectionString, integrationId, metadata) {
+	const [base, paramString] = connectionString.split("?");
+	const params = new URLSearchParams(paramString);
+	params.set("tls", "true");
+	if (metadata.caCertificateName) {
+		const path = getCACertificatePath({
+			projectRoot,
+			integrationId,
+			caCertificateName: metadata.caCertificateName
+		});
+		params.set("tlsCAFile", path);
+	}
+	return `${base}?${params.toString()}`;
+}
+function getEnvVarForSqlCells(integration, params) {
+	const sqlAlchemyInput = getSqlAlchemyInput(integration, params);
+	if (!sqlAlchemyInput) return null;
+	return {
+		name: convertToEnvironmentVariableName(getSqlEnvVarName(integration.id)),
+		value: JSON.stringify({
+			integration_id: integration.id,
+			...sqlAlchemyInput
+		})
+	};
+}
+/**
+* @returns sql alchemy input, or undefined if there is an error.
+*
+* The URL and the params are passed to SQL Alchemy's create_engine function as arguments. The params are
+* passed as keyword arguments to the function.
+* https://docs.sqlalchemy.org/en/20/core/engines.html#sqlalchemy.create_engine
+*
+* See the `query_data_source` method in Deepnote Toolkit for more details:
+* https://github.com/deepnote/deepnote-toolkit/blob/main/deepnote_toolkit/sql/sql_execution.py#L321
+*/
+function getSqlAlchemyInput(integration, params) {
+	if (integration.federated_auth_method) return null;
+	switch (integration.type) {
+		case "alloydb":
+		case "pgsql": return getPostgresSqlAlchemyInput(integration.id, params.projectRootDirectory, integration.metadata);
+		case "athena": return getAthenaSqlAlchemyInput(integration.metadata);
+		case "big-query": return getBigQuerySqlAlchemyInput(integration.metadata);
+		case "clickhouse": return getClickHouseSqlAlchemyInput(integration.id, params.projectRootDirectory, integration.metadata);
+		case "databricks": return getDatabricksSqlAlchemyInput(integration.metadata);
+		case "dremio": return getDremioSqlAlchemyInput(integration.metadata);
+		case "mariadb":
+		case "mindsdb":
+		case "mysql": return getMySqlSqlAlchemyInput(integration.id, params.projectRootDirectory, integration.metadata);
+		case "materialize": return getMaterializePostgresSqlAlchemyInput(integration.id, params.projectRootDirectory, integration.metadata);
+		case "pandas-dataframe": return { ...duckDbEnvVar };
+		case "redshift": return getRedshiftSqlAlchemyInput(integration.id, params.projectRootDirectory, integration.metadata);
+		case "snowflake": return getSnowflakeSqlAlchemyInput(integration.metadata, { snowflakePartnerIdentifier: params.snowflakePartnerIdentifier });
+		case "spanner": return getSpannerSqlAlchemyInput(integration.metadata);
+		case "sql-server": return getSQLServerVar(integration.metadata);
+		case "trino": return getTrinoEnvVars(integration.id, integration.metadata, params.projectRootDirectory);
+		default: assertNever(integration);
+	}
+}
+const getDatabricksSqlAlchemyInput = ({ httpPath, host, token, port, schema, catalog, sshEnabled, sshHost, sshPort, sshUser }) => {
+	return {
+		url: `databricks+connector://token:${encodeURIComponent(token)}@${host}:${port}`,
+		params: { connect_args: {
+			http_path: httpPath,
+			schema,
+			catalog
+		} },
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(sshEnabled),
+			host: sshHost,
+			port: sshPort,
+			user: sshUser
+		}
+	};
+};
+const getDremioSqlAlchemyInput = ({ port, host, token, schema, sshEnabled, sshHost, sshPort, sshUser }) => {
+	const url = new URL(`dremio+flight://${host}:${port}${schema ? "/" + schema : ""}`);
+	url.searchParams.set("UseEncryption", "true");
+	url.searchParams.set("Token", token);
+	return {
+		url: url.href,
+		params: {},
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(sshEnabled),
+			host: sshHost,
+			port: sshPort,
+			user: sshUser
+		}
+	};
+};
+const getSQLServerVar = ({ user, password, host, port, database, sshEnabled, sshHost, sshPort, sshUser }) => {
+	const portSuffix = port ? `:${port}` : "";
+	return {
+		url: `mssql+pymssql://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}${portSuffix}/${database}`,
+		params: {},
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(sshEnabled),
+			host: sshHost,
+			port: sshPort,
+			user: sshUser
+		}
+	};
+};
+const getPostgresSqlAlchemyInput = (integrationId, projectRootDirectory, { user, password, host, port, database, sshEnabled, sshHost, sshPort, sshUser, sslEnabled, caCertificateName }) => {
+	const portSuffix = port ? `:${port}` : "";
+	const mode = getPostgresStyleMode(caCertificateName, sslEnabled);
+	return {
+		url: `postgresql://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}${portSuffix}/${database}`,
+		params: { connect_args: {
+			keepalives: 1,
+			keepalives_idle: 30,
+			keepalives_interval: 10,
+			keepalives_count: 5,
+			sslmode: mode,
+			sslrootcert: caCertificateName ? getCACertificatePath({
+				projectRoot: projectRootDirectory,
+				integrationId,
+				caCertificateName
+			}) : void 0
+		} },
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(sshEnabled),
+			host: sshHost,
+			port: sshPort,
+			user: sshUser
+		}
+	};
+};
+const getRedshiftSqlAlchemyInput = (integrationId, projectRootDirectory, metadata) => {
+	if (isFederatedAuthMethod(metadata.authMethod)) return null;
+	const portSuffix = metadata.port ? `:${metadata.port}` : "";
+	const mode = getPostgresStyleMode(metadata.caCertificateName, metadata.sslEnabled);
+	const credentials = metadata.authMethod === DatabaseAuthMethods.UsernameAndPassword ? `${encodeURIComponent(metadata.user)}:${encodeURIComponent(metadata.password)}` : "";
+	const vars = {
+		url: `redshift+psycopg2://${credentials ? `${credentials}@` : ""}${metadata.host}${portSuffix}/${metadata.database}`,
+		params: { connect_args: {
+			keepalives: 1,
+			keepalives_idle: 30,
+			keepalives_interval: 10,
+			keepalives_count: 5,
+			sslmode: mode,
+			sslrootcert: metadata.caCertificateName ? getCACertificatePath({
+				projectRoot: projectRootDirectory,
+				integrationId,
+				caCertificateName: metadata.caCertificateName
+			}) : void 0
+		} },
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(metadata.sshEnabled),
+			host: metadata.sshHost,
+			port: metadata.sshPort,
+			user: metadata.sshUser
+		}
+	};
+	if (metadata.authMethod === AwsAuthMethods.IamRole && metadata.roleArn && metadata.roleExternalId) vars.iamParams = {
+		integrationId,
+		type: "redshift"
+	};
+	return vars;
+};
+function getPostgresStyleMode(caCertificateName, sslEnabled) {
+	if (caCertificateName) return "verify-ca";
+	if (sslEnabled) return "require";
+	return "prefer";
+}
+const getMaterializePostgresSqlAlchemyInput = (integrationId, projectRootDirectory, { user, password, host, port, database, sshEnabled, sshHost, sshPort, sshUser, sslEnabled, caCertificateName, cluster }) => {
+	const portSuffix = port ? `:${port}` : "";
+	const mode = getPostgresStyleMode(caCertificateName, sslEnabled);
+	return {
+		url: `postgresql://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}${portSuffix}/${database}?options=--cluster%3D${cluster}`,
+		params: { connect_args: {
+			sslmode: mode,
+			sslrootcert: caCertificateName ? getCACertificatePath({
+				projectRoot: projectRootDirectory,
+				integrationId,
+				caCertificateName
+			}) : void 0
+		} },
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(sshEnabled),
+			host: sshHost,
+			port: sshPort,
+			user: sshUser
+		}
+	};
+};
+const getTrinoEnvVars = (integrationId, metadata, projectRootDirectory) => {
+	return {
+		url: `trino://${encodeURIComponent(metadata.user)}:${encodeURIComponent(metadata.password)}@${metadata.host}:${metadata.port}/${encodeURIComponent(metadata.database)}`,
+		params: { connect_args: {
+			...metadata.sslEnabled ? { http_scheme: "https" } : {},
+			...metadata.caCertificateName ? { verify: getCACertificatePath({
+				projectRoot: projectRootDirectory,
+				integrationId,
+				caCertificateName: metadata.caCertificateName
+			}) } : {}
+		} },
+		param_style: "pyformat"
+	};
+};
+const getAthenaSqlAlchemyInput = ({ access_key_id, region, s3_output_path, secret_access_key, workgroup }) => {
+	const baseUrl = `awsathena+rest://${encodeURIComponent(access_key_id)}:${encodeURIComponent(secret_access_key)}@athena.${region}.amazonaws.com:443/`;
+	const params = new URLSearchParams();
+	params.set("s3_staging_dir", s3_output_path);
+	if (workgroup) params.set("work_group", workgroup);
+	return {
+		url: `${baseUrl}?${params.toString()}`,
+		params: {},
+		param_style: "pyformat"
+	};
+};
+const getClickHouseSqlAlchemyInput = (integrationId, projectRootDirectory, { user, password, host, port, database, sshEnabled, sshHost, sshPort, sshUser, sslEnabled, caCertificateName }) => {
+	const portSuffix = port ? `:${port}` : "";
+	const params = new URLSearchParams();
+	params.set("protocol", "https");
+	if (sslEnabled) {
+		params.set("secure", "true");
+		params.set("tls_mode", "strict");
+	}
+	if (caCertificateName) {
+		const certificatePath = getCACertificatePath({
+			projectRoot: projectRootDirectory,
+			integrationId,
+			caCertificateName
+		});
+		params.set("verify", certificatePath);
+	}
+	return {
+		url: `clickhouse://${password ? `${encodeURIComponent(user)}:${encodeURIComponent(password)}` : encodeURIComponent(user)}@${host}${portSuffix}/${database}?${params.toString()}`,
+		params: {},
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(sshEnabled),
+			host: sshHost,
+			port: sshPort,
+			user: sshUser
+		}
+	};
+};
+var BigQueryServiceAccountParseError = class extends Error {
+	cause;
+	constructor(message, params) {
+		super(message);
+		this.name = "BigQueryServiceAccountParseError";
+		this.cause = params.cause;
+	}
+};
+const getBigQuerySqlAlchemyInput = (metadata) => {
+	if (isFederatedAuthMetadata(metadata)) return null;
+	try {
+		return {
+			url: "bigquery://",
+			params: { credentials_info: JSON.parse(metadata.service_account) },
+			param_style: "pyformat"
+		};
+	} catch (error) {
+		throw new BigQueryServiceAccountParseError("Failed to parse bigquery service account, returning empty environment variable.", { cause: error instanceof Error ? error : new Error(String(error)) });
+	}
+};
+var SpannerServiceAccountParseError = class extends Error {
+	cause;
+	constructor(message, params) {
+		super(message);
+		this.name = "SpannerServiceAccountParseError";
+		this.cause = params.cause;
+	}
+};
+const getSpannerSqlAlchemyInput = (metadata) => {
+	try {
+		const projectId = JSON.parse(metadata.service_account).project_id;
+		if (!projectId || typeof projectId !== "string") throw new SpannerServiceAccountParseError("Failed to parse spanner service account, returning empty environment variable.", { cause: /* @__PURE__ */ new Error("project_id is missing in service account") });
+		return {
+			url: `spanner+spanner:///projects/${projectId}/instances/${metadata.instance}/databases/${metadata.database}`,
+			params: {},
+			param_style: "pyformat"
+		};
+	} catch (error) {
+		if (error instanceof SpannerServiceAccountParseError) throw error;
+		throw new SpannerServiceAccountParseError("Failed to parse spanner service account, returning empty environment variable.", { cause: error instanceof Error ? error : new Error(String(error)) });
+	}
+};
+const getMySqlSqlAlchemyInput = (integrationId, projectRootDirectory, { user, password, host, port, database, sshEnabled, sshHost, sshPort, sshUser, caCertificateName }) => {
+	const portSuffix = port ? `:${port}` : "";
+	let ssl;
+	if (caCertificateName) ssl = {
+		ca: getCACertificatePath({
+			projectRoot: projectRootDirectory,
+			integrationId,
+			caCertificateName
+		}),
+		check_hostname: false
+	};
+	else ssl = { enable: true };
+	return {
+		url: `mysql+pymysql://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}${portSuffix}/${database}`,
+		params: { connect_args: { ssl } },
+		param_style: "pyformat",
+		ssh_options: {
+			enabled: String(sshEnabled),
+			host: sshHost,
+			port: sshPort,
+			user: sshUser
+		}
+	};
+};
+function getCACertificatePath({ projectRoot, integrationId, caCertificateName }) {
+	return `${projectRoot ?? ""}/.deepnote/${integrationId}/${caCertificateName}`;
+}
+function convertToEnvironmentVariableName(str) {
+	return (/^\d/.test(str) ? `_${str}` : str).toUpperCase().replace(/[^\w]/g, "_");
+}
+function getSqlEnvVarName(integrationId) {
+	return `SQL_${integrationId}`;
+}
+function assertNever(value) {
+	throw new Error(`Unexpected value: ${value}`);
+}
+
+//#endregion
+//#region src/database-integration-metadata-schemas.ts
+const athenaMetadataSchema = z.object({
+	access_key_id: z.string(),
+	region: z.string(),
+	s3_output_path: z.string(),
+	secret_access_key: z.string(),
+	workgroup: z.string().optional()
+});
+const bigqueryMetadataSchema = z.discriminatedUnion("authMethod", [z.object({
+	authMethod: z.literal(BigQueryAuthMethods.ServiceAccount),
+	service_account: z.string()
+}), z.object({
+	authMethod: z.literal(BigQueryAuthMethods.GoogleOauth),
+	project: z.string(),
+	clientId: z.string(),
+	clientSecret: z.string()
+})]);
+const clickhouseMetadataSchema = z.object({
+	host: z.string(),
+	user: z.string(),
+	password: z.string().optional(),
+	database: z.string(),
+	port: z.string().optional(),
+	sshEnabled: z.boolean().optional(),
+	sshHost: z.string().optional(),
+	sshPort: z.string().optional(),
+	sshUser: z.string().optional(),
+	sslEnabled: z.boolean().optional(),
+	caCertificateName: z.string().optional(),
+	caCertificateText: z.string().optional()
+});
+const databricksMetadataSchema = z.object({
+	host: z.string(),
+	httpPath: z.string(),
+	token: z.string(),
+	port: z.string(),
+	schema: z.string().optional(),
+	catalog: z.string().optional(),
+	sshEnabled: z.boolean().optional(),
+	sshHost: z.string().optional(),
+	sshPort: z.string().optional(),
+	sshUser: z.string().optional()
+});
+const dremioMetadataSchema = z.object({
+	schema: z.string(),
+	host: z.string(),
+	port: z.string(),
+	token: z.string(),
+	sshEnabled: z.boolean().optional(),
+	sshHost: z.string().optional(),
+	sshPort: z.string().optional(),
+	sshUser: z.string().optional()
+});
+const mongodbMetadataSchema = z.object({
+	connection_string: z.string(),
+	rawConnectionString: z.string().optional(),
+	prefix: z.string().optional(),
+	host: z.string().optional(),
+	port: z.string().optional(),
+	user: z.string().optional(),
+	password: z.string().optional(),
+	database: z.string().optional(),
+	options: z.string().optional(),
+	sshEnabled: z.boolean().optional(),
+	sshHost: z.string().optional(),
+	sshPort: z.string().optional(),
+	sshUser: z.string().optional(),
+	sslEnabled: z.boolean().optional(),
+	caCertificateName: z.string().optional(),
+	caCertificateText: z.string().optional()
+});
+const pandasDataframeMetadataSchema = z.object({});
+const commonRedshiftMetadataSchema = z.object({
+	database: z.string(),
+	host: z.string(),
+	port: z.string().optional(),
+	sshEnabled: z.boolean().optional(),
+	sshHost: z.string().optional(),
+	sshPort: z.string().optional(),
+	sshUser: z.string().optional(),
+	sslEnabled: z.boolean().optional(),
+	caCertificateName: z.string().optional(),
+	caCertificateText: z.string().optional()
+});
+const redshiftMetadataSchema = z.discriminatedUnion("authMethod", [
+	commonRedshiftMetadataSchema.extend({
+		authMethod: z.literal(DatabaseAuthMethods.UsernameAndPassword),
+		user: z.string(),
+		password: z.string()
+	}),
+	commonRedshiftMetadataSchema.extend({
+		authMethod: z.literal(AwsAuthMethods.IamRole),
+		roleArn: z.string(),
+		roleExternalId: z.string(),
+		roleNonce: z.string()
+	}),
+	commonRedshiftMetadataSchema.extend({ authMethod: z.literal(DatabaseAuthMethods.IndividualCredentials) })
+]);
+const commonSnowflakeMetadataSchema = z.object({
+	accountName: z.string(),
+	warehouse: z.string().optional(),
+	database: z.string().optional(),
+	role: z.string().optional()
+});
+const snowflakeMetadataSchema = z.discriminatedUnion("authMethod", [
+	commonSnowflakeMetadataSchema.extend({
+		authMethod: z.literal(SnowflakeAuthMethods.Password),
+		username: z.string(),
+		password: z.string()
+	}),
+	commonSnowflakeMetadataSchema.extend({
+		authMethod: z.literal(SnowflakeAuthMethods.Okta),
+		clientId: z.string(),
+		clientSecret: z.string(),
+		oktaSubdomain: z.string(),
+		identityProvider: z.string(),
+		authorizationServer: z.string()
+	}),
+	commonSnowflakeMetadataSchema.extend({
+		authMethod: z.literal(SnowflakeAuthMethods.NativeSnowflake),
+		clientId: z.string(),
+		clientSecret: z.string()
+	}),
+	commonSnowflakeMetadataSchema.extend({
+		authMethod: z.literal(SnowflakeAuthMethods.AzureAd),
+		clientId: z.string(),
+		clientSecret: z.string(),
+		resource: z.string(),
+		tenant: z.string()
+	}),
+	commonSnowflakeMetadataSchema.extend({ authMethod: z.literal(SnowflakeAuthMethods.KeyPair) }),
+	commonSnowflakeMetadataSchema.extend({
+		authMethod: z.literal(SnowflakeAuthMethods.ServiceAccountKeyPair),
+		username: z.string(),
+		privateKey: z.string(),
+		privateKeyPassphrase: z.string().optional()
+	})
+]);
+const spannerMetadataSchema = z.object({
+	service_account: z.string(),
+	dataBoostEnabled: z.boolean(),
+	instance: z.string(),
+	database: z.string()
+});
+const trinoMetadataSchema = z.object({
+	host: z.string(),
+	user: z.string(),
+	password: z.string(),
+	database: z.string(),
+	port: z.string(),
+	sshEnabled: z.boolean().optional(),
+	sshHost: z.string().optional(),
+	sshPort: z.string().optional(),
+	sshUser: z.string().optional(),
+	sslEnabled: z.boolean().optional(),
+	caCertificateName: z.string().optional(),
+	caCertificateText: z.string().optional()
+});
+const commonDatabaseSchema = z.object({
+	host: z.string(),
+	user: z.string(),
+	password: z.string(),
+	database: z.string(),
+	sshEnabled: z.boolean().optional(),
+	sshHost: z.string().optional(),
+	sshPort: z.string().optional(),
+	sshUser: z.string().optional()
+});
+const alloydbMetadataSchema = commonDatabaseSchema.extend({
+	port: z.string().optional(),
+	sslEnabled: z.boolean().optional(),
+	caCertificateName: z.string().optional(),
+	caCertificateText: z.string().optional()
+});
+const mariadbMetadataSchema = commonDatabaseSchema.extend({
+	port: z.string().optional(),
+	caCertificateName: z.string().optional()
+});
+const mindsdbMetadataSchema = commonDatabaseSchema.extend({
+	port: z.string().optional(),
+	caCertificateName: z.string().optional()
+});
+const mysqlMetadataSchema = commonDatabaseSchema.extend({
+	port: z.string().optional(),
+	caCertificateName: z.string().optional()
+});
+const pgsqlMetadataSchema = commonDatabaseSchema.extend({
+	port: z.string().optional(),
+	sslEnabled: z.boolean().optional(),
+	caCertificateName: z.string().optional(),
+	caCertificateText: z.string().optional()
+});
+const materializeMetadataSchema = pgsqlMetadataSchema.extend({ cluster: z.string() });
+const sqlServerMetadataSchema = commonDatabaseSchema.extend({ port: z.string() });
+const databaseMetadataSchemasByType = {
+	"alloydb": alloydbMetadataSchema,
+	"athena": athenaMetadataSchema,
+	"big-query": bigqueryMetadataSchema,
+	"clickhouse": clickhouseMetadataSchema,
+	"databricks": databricksMetadataSchema,
+	"dremio": dremioMetadataSchema,
+	"mariadb": mariadbMetadataSchema,
+	"materialize": materializeMetadataSchema,
+	"mindsdb": mindsdbMetadataSchema,
+	"mongodb": mongodbMetadataSchema,
+	"mysql": mysqlMetadataSchema,
+	"pandas-dataframe": pandasDataframeMetadataSchema,
+	"pgsql": pgsqlMetadataSchema,
+	"redshift": redshiftMetadataSchema,
+	"snowflake": snowflakeMetadataSchema,
+	"spanner": spannerMetadataSchema,
+	"sql-server": sqlServerMetadataSchema,
+	"trino": trinoMetadataSchema
+};
+
+//#endregion
+//#region src/database-integration-types.ts
+const sqlIntegrationTypes = [
+	"alloydb",
+	"athena",
+	"big-query",
+	"clickhouse",
+	"databricks",
+	"dremio",
+	"mariadb",
+	"materialize",
+	"mindsdb",
+	"mysql",
+	"pandas-dataframe",
+	"pgsql",
+	"redshift",
+	"snowflake",
+	"spanner",
+	"sql-server",
+	"trino"
+];
+const databaseIntegrationTypes = [...sqlIntegrationTypes, "mongodb"];
+const databaseIntegrationTypesWithSslSupport = [
+	"clickhouse",
+	"dremio",
+	"mariadb",
+	"mindsdb",
+	"mongodb",
+	"mysql",
+	"pgsql",
+	"redshift",
+	"trino"
+];
+
+//#endregion
+export { AwsAuthMethods, BigQueryAuthMethods, BigQueryServiceAccountParseError, DatabaseAuthMethods, SnowflakeAuthMethods, SpannerServiceAccountParseError, databaseIntegrationTypes, databaseIntegrationTypesWithSslSupport, databaseMetadataSchemasByType, getIntegrationListEnv, getSqlAlchemyInput, isFederatedAuthMetadata, isFederatedAuthMethod, sqlIntegrationTypes };