Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
import type { FieldValues } from "react-hook-form";
import { z } from "zod";
import {
DynamicSecretProviders,
SqlProviders,
TUpdateDynamicSecretDTO
} from "@app/hooks/api/dynamicSecret/types";
import type { VaultDatabaseRole } from "@app/hooks/api/migration/types";
import {
createDynamicSecretProviderFormSchema,
DEFAULT_DYNAMIC_SECRET_USERNAME_TEMPLATE,
editDynamicSecretProviderFormSchema,
normalizeDynamicSecretUsernameTemplateForCreate,
normalizeDynamicSecretUsernameTemplateForEdit
} from "../schemas";
import type {
TCreateDynamicSecretProviderDTO,
TCreateDynamicSecretProviderFormContext,
TDynamicSecretProviderFormMode,
TDynamicSecretProviderFormValues,
TEditDynamicSecretProviderFormContext
} from "../types";
export const SQL_DATABASE_CUSTOM_RENDERER_REASONS = [
"conditional-fields",
"repeatable-fields",
"permission-aware-fields",
"import-workflow",
"non-scalar-value",
"context-aware-fields"
] as const;
export type TSqlPasswordRequirements = {
length: number;
required: {
lowercase: number;
uppercase: number;
digits: number;
symbols: number;
};
allowedSymbols?: string;
};
export type TSqlDatabaseInputs = {
client?: SqlProviders;
host?: string;
port?: number;
database?: string;
username?: string;
password?: string;
passwordRequirements?: TSqlPasswordRequirements;
creationStatement?: string;
revocationStatement?: string;
renewStatement?: string;
sslEnabled?: boolean;
ca?: string;
sslRejectUnauthorized?: boolean;
gatewayId?: string | null;
gatewayPoolId?: string | null;
};
export type TSqlDatabaseFormValues = TDynamicSecretProviderFormValues<TSqlDatabaseInputs> &
FieldValues & {
metadata?: { key: string; value: string }[];
};
export const sqlPasswordRequirementsSchema = z
.object({
length: z.number().min(1).max(250),
required: z
.object({
lowercase: z.number().min(0),
uppercase: z.number().min(0),
digits: z.number().min(0),
symbols: z.number().min(0)
})
.refine(
(required) => Object.values(required).reduce((sum, count) => sum + count, 0) <= 250,
"Sum of required characters cannot exceed 250"
),
allowedSymbols: z.string().optional()
})
.refine(
({ length, required }) =>
Object.values(required).reduce((sum, count) => sum + count, 0) <= length,
"Sum of required characters cannot exceed the total length"
);
const metadataSchema = z
.array(
z.object({
key: z.string().trim().min(1),
value: z.string().trim().default("")
})
)
.optional();
export const sqlDatabaseCreateInputsSchema = z.object({
client: z.nativeEnum(SqlProviders),
host: z.string().toLowerCase().min(1),
port: z.number(),
database: z.string().min(1),
username: z.string().min(1),
password: z.string().min(1),
passwordRequirements: sqlPasswordRequirementsSchema.optional(),
creationStatement: z.string().min(1),
revocationStatement: z.string().min(1),
renewStatement: z.string().optional(),
sslEnabled: z.boolean().optional(),
ca: z.string().optional(),
sslRejectUnauthorized: z.boolean().default(true),
gatewayId: z.string().optional(),
gatewayPoolId: z.string().optional()
});
export const sqlDatabaseEditInputsSchema = z
.object({
client: z.nativeEnum(SqlProviders),
host: z.string().toLowerCase().min(1),
port: z.number(),
database: z.string().min(1),
username: z.string().min(1),
password: z.string().min(1),
passwordRequirements: sqlPasswordRequirementsSchema.optional(),
creationStatement: z.string().min(1),
revocationStatement: z.string().min(1),
renewStatement: z.string().optional(),
sslEnabled: z.boolean().optional(),
ca: z.string().optional(),
sslRejectUnauthorized: z.boolean().optional(),
gatewayId: z.string().optional().nullable(),
gatewayPoolId: z.string().optional().nullable()
})
.partial();
export const sqlDatabaseCreateFormSchema = createDynamicSecretProviderFormSchema(
sqlDatabaseCreateInputsSchema
).extend({ metadata: metadataSchema }) as z.ZodType<TSqlDatabaseFormValues>;
export const sqlDatabaseEditFormSchema = editDynamicSecretProviderFormSchema(
sqlDatabaseEditInputsSchema,
{ usernameTemplateSchema: z.string().trim().nullable().optional() }
).extend({ metadata: metadataSchema }) as z.ZodType<TSqlDatabaseFormValues>;
export const getSqlStatements = (provider: SqlProviders) => {
if (provider === SqlProviders.MySql) {
return {
creationStatement:
"CREATE USER \"{{username}}\"@'%' IDENTIFIED BY '{{password}}';\nGRANT ALL ON \"{{database}}\".* TO \"{{username}}\"@'%';",
renewStatement: "",
revocationStatement:
'REVOKE ALL PRIVILEGES ON "{{database}}".* FROM "{{username}}"@\'%\';\nDROP USER "{{username}}"@\'%\';'
};
}
if (provider === SqlProviders.Oracle) {
return {
creationStatement:
'CREATE USER "{{username}}" IDENTIFIED BY "{{password}}";\nGRANT CONNECT TO "{{username}}";\nGRANT CREATE SESSION TO "{{username}}";',
renewStatement: "",
revocationStatement:
'REVOKE CONNECT FROM "{{username}}";\nREVOKE CREATE SESSION FROM "{{username}}";\nDROP USER "{{username}}";'
};
}
if (provider === SqlProviders.MsSQL) {
return {
creationStatement:
"CREATE LOGIN [{{username}}] WITH PASSWORD = '{{password}}';\nCREATE USER [{{username}}] FOR LOGIN [{{username}}];\nGRANT SELECT, INSERT, UPDATE, DELETE ON SCHEMA::dbo TO [{{username}}];",
renewStatement: "",
revocationStatement: "DROP USER [{{username}}];\nDROP LOGIN [{{username}}];"
};
}
return {
creationStatement:
"CREATE USER \"{{username}}\" WITH ENCRYPTED PASSWORD '{{password}}' VALID UNTIL '{{expiration}}';\nGRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO \"{{username}}\";",
renewStatement: "ALTER ROLE \"{{username}}\" VALID UNTIL '{{expiration}}';",
revocationStatement:
'REVOKE ALL PRIVILEGES ON ALL TABLES IN SCHEMA public FROM "{{username}}";\nDROP ROLE "{{username}}";'
};
};
export const getSqlDefaultPort = (provider: SqlProviders) => {
switch (provider) {
case SqlProviders.MySql:
return 3306;
case SqlProviders.Oracle:
return 1521;
case SqlProviders.MsSQL:
return 1433;
default:
return 5432;
}
};
export const getDefaultSqlPasswordRequirements = (
provider: SqlProviders
): TSqlPasswordRequirements => ({
length: provider === SqlProviders.Oracle ? 30 : 48,
required: { lowercase: 1, uppercase: 1, digits: 1, symbols: 0 },
allowedSymbols: "-_.~!*"
});
export const getSqlClientResetValues = (provider: SqlProviders) => ({
...getSqlStatements(provider),
port: getSqlDefaultPort(provider),
passwordLength: getDefaultSqlPasswordRequirements(provider).length
});
export const normalizeSqlGatewayValueForMode = (
mode: TDynamicSecretProviderFormMode,
value: string | null
) => (mode === "create" ? (value ?? undefined) : value);
export const getSqlDatabaseCreateDefaultValues = (
context: TCreateDynamicSecretProviderFormContext
): TSqlDatabaseFormValues => ({
name: "",
defaultTTL: "1h",
maxTTL: "24h",
environment: context.isSingleEnvironmentMode ? context.environments[0] : undefined,
metadata: [],
usernameTemplate: DEFAULT_DYNAMIC_SECRET_USERNAME_TEMPLATE,
inputs: {
client: SqlProviders.Postgres,
host: "",
port: getSqlDefaultPort(SqlProviders.Postgres),
database: "default",
username: "",
password: "",
...getSqlStatements(SqlProviders.Postgres),
sslRejectUnauthorized: true,
gatewayId: undefined,
gatewayPoolId: undefined,
passwordRequirements: getDefaultSqlPasswordRequirements(SqlProviders.Postgres)
}
});
export const getSqlDatabaseEditDefaultValues = (
context: TEditDynamicSecretProviderFormContext
): TSqlDatabaseFormValues => {
const inputs = context.dynamicSecret.inputs as TSqlDatabaseInputs;
const client = inputs.client ?? SqlProviders.Postgres;
return {
name: context.dynamicSecret.name,
defaultTTL: context.dynamicSecret.defaultTTL,
maxTTL: context.dynamicSecret.maxTTL,
metadata: context.dynamicSecret.metadata,
usernameTemplate:
context.dynamicSecret.usernameTemplate || DEFAULT_DYNAMIC_SECRET_USERNAME_TEMPLATE,
inputs: {
...inputs,
passwordRequirements: inputs.passwordRequirements ?? getDefaultSqlPasswordRequirements(client)
}
};
};
export const getSqlDatabaseCreatePayload = (
values: TSqlDatabaseFormValues,
context: TCreateDynamicSecretProviderFormContext
): TCreateDynamicSecretProviderDTO<DynamicSecretProviders.SqlDatabase> => {
const inputs = sqlDatabaseCreateInputsSchema.parse(values.inputs);
return {
provider: { type: DynamicSecretProviders.SqlDatabase, inputs },
maxTTL: values.maxTTL ?? undefined,
name: values.name,
path: context.secretPath,
defaultTTL: values.defaultTTL,
projectSlug: context.projectSlug,
environmentSlug: values.environment?.slug ?? "",
metadata: values.metadata,
usernameTemplate: normalizeDynamicSecretUsernameTemplateForCreate(values.usernameTemplate)
};
};
export const getSqlDatabaseEditPayload = (
values: TSqlDatabaseFormValues,
context: TEditDynamicSecretProviderFormContext
): TUpdateDynamicSecretDTO => {
const inputs = sqlDatabaseEditInputsSchema.parse(values.inputs);
return {
name: context.dynamicSecret.name,
path: context.secretPath,
projectSlug: context.projectSlug,
environmentSlug: context.environment,
data: {
maxTTL: values.maxTTL || undefined,
defaultTTL: values.defaultTTL,
inputs: {
...inputs,
gatewayId: inputs.gatewayId ?? null,
gatewayPoolId: inputs.gatewayPoolId ?? null
},
newName: values.name === context.dynamicSecret.name ? undefined : values.name,
metadata: values.metadata,
usernameTemplate: normalizeDynamicSecretUsernameTemplateForEdit(values.usernameTemplate)
}
};
};
const getSqlProviderFromVaultPlugin = (pluginName?: string) => {
const normalizedPluginName = pluginName?.toLowerCase() ?? "";
if (normalizedPluginName.includes("mysql")) return SqlProviders.MySql;
if (normalizedPluginName.includes("oracle")) return SqlProviders.Oracle;
if (normalizedPluginName.includes("mssql")) return SqlProviders.MsSQL;
return SqlProviders.Postgres;
};
const convertVaultVariables = (statement: string) =>
statement.replace(/\{\{name\}\}/g, "{{username}}");
export const getSqlDatabaseVaultImportValues = (role: VaultDatabaseRole) => {
const client = getSqlProviderFromVaultPlugin(role.config.plugin_name);
const inputs: Partial<TSqlDatabaseInputs> = { client };
const connectionUrl = role.config.connection_details.connection_url ?? "";
let connectionUrlParseFailed = false;
try {
const trimmedUrl = connectionUrl.trim();
if (!trimmedUrl) throw new Error("Empty URL");
const setConnectionDetails = (host: string, port: number | undefined, database: string) => {
if (host) inputs.host = host;
const parsedPort = port ?? getSqlDefaultPort(client);
inputs.port = Number.isNaN(parsedPort) ? getSqlDefaultPort(client) : parsedPort;
if (database) inputs.database = database;
};
const parseStandardUrl = (url: URL, dbFromParams?: string) => {
if (url.username) inputs.username = url.username;
const port = url.port ? parseInt(url.port, 10) : undefined;
setConnectionDetails(url.hostname, port, dbFromParams || url.pathname.replace(/^\//, ""));
};
if (client === SqlProviders.MySql) {
const tcpMatch = trimmedUrl.match(/@tcp\(([^:]+):?(\d+)?\)\/([^?#]+)/);
if (tcpMatch) {
setConnectionDetails(
tcpMatch[1],
tcpMatch[2] ? parseInt(tcpMatch[2], 10) : undefined,
tcpMatch[3]
);
} else if (trimmedUrl.includes("://")) {
parseStandardUrl(new URL(trimmedUrl));
}
} else if (client === SqlProviders.Oracle) {
const oracleMatch = trimmedUrl.match(/@(?:\/\/)?([^:/]+):?(\d+)?\/(.+)/);
if (oracleMatch) {
setConnectionDetails(
oracleMatch[1],
oracleMatch[2] ? parseInt(oracleMatch[2], 10) : undefined,
oracleMatch[3]
);
}
} else if (client === SqlProviders.MsSQL) {
const url = new URL(trimmedUrl);
parseStandardUrl(
url,
url.searchParams.get("database") || url.searchParams.get("databaseName") || ""
);
} else {
parseStandardUrl(new URL(trimmedUrl));
}
} catch {
connectionUrlParseFailed = true;
}
if (role.config.connection_details.username) {
inputs.username = role.config.connection_details.username;
}
if (role.config.connection_details.tls_ca) inputs.ca = role.config.connection_details.tls_ca;
if (role.creation_statements?.length) {
inputs.creationStatement = role.creation_statements.map(convertVaultVariables).join("\n");
}
if (role.revocation_statements?.length) {
inputs.revocationStatement = role.revocation_statements.map(convertVaultVariables).join("\n");
}
if (role.renew_statements?.length) {
inputs.renewStatement = role.renew_statements.map(convertVaultVariables).join("\n");
}
return {
name: role.name,
defaultTTL: role.default_ttl ? `${role.default_ttl}s` : undefined,
maxTTL: role.max_ttl ? `${role.max_ttl}s` : undefined,
inputs,
connectionUrlParseFailed
};
};