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
Merge branch 'main' into calvin/eng-5685-add-stripe-api-key-secret-rotation-integration
Calvin63bb8cbbd931
diff --cc backend/e2e-test/routes/v2/secret-rotation.spec.tsindex a6dc350245,0000000000..89d60e0227mode 100644,000000..100644--- a/backend/e2e-test/routes/v2/secret-rotation.spec.ts+++ b/backend/e2e-test/routes/v2/secret-rotation.spec.ts@@@ -1,391 -1,0 +1,391 @@@+import { randomUUID } from "crypto";+import { FakeIamRotationMode, fakeIamUserSecret } from "e2e-test/fakes/aws-iam-user-secret-rotation-fns";+import { createAwsAppConnection, deleteAwsAppConnection } from "e2e-test/testUtils/app-connections";+import { createIsolatedOrgAndProject } from "e2e-test/testUtils/fixtures";+import { createFolder } from "e2e-test/testUtils/folders";+import {+ checkRotationCredentials,+ createSecretRotation,+ deleteSecretRotation,+ getGeneratedCredentials,+ getSecretRotation,+ listSecretRotations,+ rotateSecretRotation+} from "e2e-test/testUtils/secret-rotations";+import { createSecretV2, getSecretsV2, updateSecretV2 } from "e2e-test/testUtils/secrets";++import { SecretRotationStatus } from "@app/ee/services/secret-rotation-v2/secret-rotation-v2-enums";++// What is under test is the rotation plumbing: issuing the first credential, publishing each new+// one into the two mapped secrets, which credential the provider is handed to retire, and what+// survives a failure. The provider is AWS IAM user secrets, faked for the whole run+// (e2e-test/fakes/aws-iam-user-secret-rotation-fns.ts and the alias block in+// vitest.e2e.config.mts), so none of this reaches IAM.+//+// Every assertion is on state a user or an operator could see: the secrets at the path, the keys+// on the IAM user, the rotation's own status. Nothing asserts that the factory was called, or+// with what. The two rotation shapes are covered by running the same lifecycle against a fake in+// each mode, and because each mode retires a different one of the two credentials the service+// offers it, the surviving keys are what say the service offered the right ones.++const ENV = "dev";++// The two secret keys the rotation writes its credentials to, which is the whole of what it+// publishes into the project.+const SECRET_KEYS = { accessKeyId: "AWS_ACCESS_KEY_ID", secretAccessKey: "AWS_SECRET_ACCESS_KEY" };++// The fake issues keys in order from a counter that resets between tests, so a spec can name the+// credential it expects rather than reading it back out of the fake first. `credential(1)` is the+// one creating the rotation issued, `credential(2)` the one the first rotation issued, and so on.+const credential = (sequence: number) => ({+ accessKeyId: `AKIAFAKE${String(sequence).padStart(4, "0")}`,+ secretAccessKey: `fake-secret-access-key-${String(sequence).padStart(4, "0")}`+});++// The mapped secrets as they look when they are holding this credential.+const secretsHolding = (sequence: number) => ({+ [SECRET_KEYS.accessKeyId]: credential(sequence).accessKeyId,+ [SECRET_KEYS.secretAccessKey]: credential(sequence).secretAccessKey+});++// The IAM user's keys when exactly these credentials are live on it.+const liveKeys = (...sequences: number[]) =>+ Object.fromEntries(+ sequences.map((sequence) => [credential(sequence).accessKeyId, credential(sequence).secretAccessKey])+ );++describe("Secret rotations", async () => {+ // Rotating is synchronous but does a fair amount of KMS work per call, and a lifecycle test+ // creates an org, a project, a connection and a rotation and then rotates twice, which is more+ // than the 5s default allows for.+ vi.setConfig({ testTimeout: 30_000, hookTimeout: 30_000 });++ let projectId: string;+ let connectionId: string;+ let authToken: string;+ let cleanupOrg: () => Promise<void>;++ const secretsAt = async (secretPath: string) => {+ const { secrets } = await getSecretsV2({ authToken, workspaceId: projectId, environmentSlug: ENV, secretPath });+ return Object.fromEntries(secrets.map((secret) => [secret.secretKey, secret.secretValue]));+ };++ // Creates a rotation at /services with the standard secret keys. The options are the two things+ // tests vary: the keys it publishes to (for the tests about keys already being taken) and the+ // status a refused creation is expected to answer with.+ const newRotation = async (+ name: string,+ options: {+ secretsMapping?: { accessKeyId: string; secretAccessKey: string };+ secretPath?: string;+ expectStatusCode?: number;+ } = {}+ ) =>+ createSecretRotation({+ name,+ projectId,+ connectionId,+ environmentSlug: ENV,+ secretPath: options.secretPath ?? "/services",+ secretsMapping: options.secretsMapping ?? SECRET_KEYS,+ expectStatusCode: options.expectStatusCode,+ authToken+ });++ // A fresh org and project per test, so no test can be reached by another's writes or teardown.+ // An app connection is org-scoped rather than project-scoped, so sharing one would leave a+ // single row every test's rotations hang off. A rotation left behind in a shared org would also+ // be picked up by the rotation cron, which under NODE_ENV=test treats every auto-enabled+ // rotation as due and runs it inline once a minute.+ beforeEach(async () => {+ fakeIamUserSecret.reset();++ ({ projectId, authToken, cleanup: cleanupOrg } = await createIsolatedOrgAndProject("secret-rotation-e2e"));++ connectionId = await createAwsAppConnection({+ name: `secret-rotation-e2e-${randomUUID().slice(0, 8)}`,+ authToken+ });++ await createFolder({ authToken, workspaceId: projectId, environmentSlug: ENV, secretPath: "/", name: "services" });+ });++ afterEach(async () => {+ // Order matters. A rotation holds a foreign key to the connection, so the connection delete+ // fails on the constraint while any rotation is still pointing at it. Whatever each test left+ // is read back from the project rather than tracked, so a test that deletes its own rotation+ // needs no bookkeeping here. Neither flag is set: the secrets go with the org, and the fake's+ // keys go with the reset.+ const rotations = await listSecretRotations({ projectId, authToken });+ for (const rotation of rotations) {+ // eslint-disable-next-line no-await-in-loop+ await deleteSecretRotation({+ rotationId: rotation.id,+ deleteSecrets: false,+ revokeGeneratedCredentials: false,+ authToken+ });+ }++ await deleteAwsAppConnection({ connectionId, authToken });+ await cleanupOrg();+ });++ describe("Creating a rotation issues the first credential and publishes it", () => {+ test("The mapped secrets hold the issued credential and the provider has one live key", async () => {+ const { secretRotation } = await newRotation("publishes-first-credential");++ expect(await secretsAt("/services")).toEqual(secretsHolding(1));+ expect(fakeIamUserSecret.keys()).toEqual(liveKeys(1));+ expect(secretRotation!.activeIndex).toBe(0);+ expect(secretRotation!.rotationStatus).toBe(SecretRotationStatus.Success);+ // Auto rotation is off, so there is nothing for the cron to pick up:+ // findSecretRotationsToQueue gates on this being set as well as on isAutoRotationEnabled.+ expect(secretRotation!.nextRotationAt).toBeNull();+ });+ });++ // The two provider shapes. Both rotate through the same service call and both are handed the+ // same two credentials; they differ in which one they retire, so the keys left live are what+ // show the service handed over the right ones. Getting them the wrong way round would revoke+ // the credential the mapped secrets are publishing.+ describe("A rotation publishes the new credential and offers the provider the one it displaces", () => {+ test("A provider that replaces its credential in place is left with only the published one", async () => {+ fakeIamUserSecret.setMode(FakeIamRotationMode.ReplaceInPlace);++ const { secretRotation } = await newRotation("replace-in-place");+ const rotationId = secretRotation!.id;++ // The provider retires the credential it was told is active, which is the one the mapped+ // secrets were publishing until this call. Its predecessor is long dead.+ const first = await rotateSecretRotation({ rotationId, authToken });++ expect(await secretsAt("/services")).toEqual(secretsHolding(2));+ expect(fakeIamUserSecret.keys()).toEqual(liveKeys(2));+ expect(first.secretRotation!.activeIndex).toBe(1);+ expect(first.secretRotation!.rotationStatus).toBe(SecretRotationStatus.Success);+ expect(first.secretRotation!.nextRotationAt).toBeNull();++ const second = await rotateSecretRotation({ rotationId, authToken });++ expect(await secretsAt("/services")).toEqual(secretsHolding(3));+ expect(fakeIamUserSecret.keys()).toEqual(liveKeys(3));+ // Back to the first slot: two slots, alternating.+ expect(second.secretRotation!.activeIndex).toBe(0);+ });++ test("A provider that runs two credentials keeps the previous one live and retires the one before it", async () => {+ fakeIamUserSecret.setMode(FakeIamRotationMode.IssueAndDisplace);++ const { secretRotation } = await newRotation("issue-and-displace");+ const rotationId = secretRotation!.id;++ // Nothing is displaced on the first rotation, because only one slot has ever been filled,+ // so the credential creating the rotation issued stays live alongside the new one.+ const first = await rotateSecretRotation({ rotationId, authToken });++ expect(await secretsAt("/services")).toEqual(secretsHolding(2));+ expect(fakeIamUserSecret.keys()).toEqual(liveKeys(1, 2));+ expect(first.secretRotation!.activeIndex).toBe(1);++ // The second rotation displaces the first credential, never the one the mapped secrets are+ // publishing.+ const second = await rotateSecretRotation({ rotationId, authToken });++ expect(await secretsAt("/services")).toEqual(secretsHolding(3));+ expect(fakeIamUserSecret.keys()).toEqual(liveKeys(2, 3));+ expect(second.secretRotation!.activeIndex).toBe(0);+ });++ test("Both credentials are readable, newest in the slot the active index names", async () => {+ const { secretRotation } = await newRotation("generated-credentials");+ const rotationId = secretRotation!.id;++ await rotateSecretRotation({ rotationId, authToken });+ await rotateSecretRotation({ rotationId, authToken });++ expect(await getGeneratedCredentials({ rotationId, authToken })).toEqual({+ generatedCredentials: [credential(3), credential(2)],+ activeIndex: 0+ });+ });+ });++ describe("A rotation that cannot issue a credential changes nothing", () => {+ test("A provider that refuses the first credential leaves no rotation and no secrets", async () => {+ fakeIamUserSecret.failIssueWith("IAM denied CreateAccessKey");++ const { error } = await newRotation("issue-refused", { expectStatusCode: 400 });++ expect(error!.message).toContain("IAM denied CreateAccessKey");+ expect(fakeIamUserSecret.keys()).toEqual({});+ expect(await secretsAt("/services")).toEqual({});+ expect(await listSecretRotations({ projectId, authToken })).toEqual([]);+ });++ test("A provider that refuses a later credential leaves the working one published", async () => {+ const { secretRotation } = await newRotation("issue-refused-later");+ const rotationId = secretRotation!.id;++ fakeIamUserSecret.failIssueWith("IAM throttled CreateAccessKey");++ // A provider failure answers 500 rather than 4xx: rotateSecretRotation wraps whatever+ // rotateGeneratedCredentials threw in an InternalServerError.+ const { error } = await rotateSecretRotation({ rotationId, authToken, expectStatusCode: 500 });+ expect(error!.message).toContain("IAM throttled CreateAccessKey");++ // The credential users hold is untouched, at the provider and in the mapped secrets.+ expect(fakeIamUserSecret.keys()).toEqual(liveKeys(1));+ expect(await secretsAt("/services")).toEqual(secretsHolding(1));++ const failed = await getSecretRotation({ rotationId, authToken });+ expect(failed.rotationStatus).toBe(SecretRotationStatus.Failed);+ expect(failed.lastRotationMessage).toContain("IAM throttled CreateAccessKey");+ expect(failed.activeIndex).toBe(0);+ });++ test("A provider that fails after the new credential is published reports failure on a rotation that happened", async () => {+ const { secretRotation } = await newRotation("fails-after-publish");+ const rotationId = secretRotation!.id;++ fakeIamUserSecret.failAfterPersistWith("IAM denied DeleteAccessKey");++ const { error } = await rotateSecretRotation({ rotationId, authToken, expectStatusCode: 500 });+ expect(error!.message).toContain("IAM denied DeleteAccessKey");++ // The write half of the rotation committed before the provider threw, so the new credential+ // is live and published while the rotation reports failed. A provider that retires the+ // displaced credential after publishing rather than before lands here.+ expect(await secretsAt("/services")).toEqual(secretsHolding(2));++ const failed = await getSecretRotation({ rotationId, authToken });+ expect(failed.activeIndex).toBe(1);+ expect(failed.rotationStatus).toBe(SecretRotationStatus.Failed);+ });+ });++ describe("A rotation is created against one free set of secret keys at one existing secret path", () => {+ test("Creating a rotation is refused when the name is already used at the path", async () => {+ await newRotation("taken-name");++ const { error } = await newRotation("taken-name", {+ // Different keys, so this can only fail on the name.+ secretsMapping: { accessKeyId: "OTHER_ACCESS_KEY_ID", secretAccessKey: "OTHER_SECRET_ACCESS_KEY" },+ expectStatusCode: 400+ });++ expect(error!.message).toContain("taken-name");+ expect(error!.message).toContain("/services");+ expect(await listSecretRotations({ projectId, authToken })).toHaveLength(1);+ });++ test("Creating a rotation is refused when a mapped secret key already exists", async () => {+ await createSecretV2({+ authToken,+ workspaceId: projectId,+ environmentSlug: ENV,+ secretPath: "/services",+ key: "HAND_WRITTEN_KEY",+ value: "hand-written-value"+ });++ const { error } = await newRotation("taken-key", {+ secretsMapping: { accessKeyId: "HAND_WRITTEN_KEY", secretAccessKey: "OTHER_SECRET_ACCESS_KEY" },+ expectStatusCode: 400+ });++ expect(error!.message).toContain("HAND_WRITTEN_KEY");+ // The hand-written secret is still its own, and no credential was issued for a rotation+ // that was refused before it reached the provider.+ expect(await secretsAt("/services")).toEqual({ HAND_WRITTEN_KEY: "hand-written-value" });+ expect(fakeIamUserSecret.keys()).toEqual({});+ });++ test("Creating a rotation is refused when the secret path does not exist", async () => {+ const { error } = await newRotation("missing-path", { secretPath: "/does/not/exist", expectStatusCode: 400 });++ expect(error!.message).toContain("/does/not/exist");+ expect(error!.message).toContain(ENV);+ expect(fakeIamUserSecret.keys()).toEqual({});+ });+ });++ describe("The rotation owns its mapped secrets until it is deleted", () => {+ test("A mapped secret cannot be given a value by hand", async () => {+ await newRotation("owns-secrets");+- const { error } = await updateSecretV2({++ await updateSecretV2({+ workspaceId: projectId,+ environmentSlug: ENV,+ secretPath: "/services",+ key: SECRET_KEYS.accessKeyId,+ value: "hand-written-value",- authToken,- expectStatusCode: 400++ authToken++ }).expect((res) => {++ expect(res.statusCode).toBe(400);++ expect(res.json().message).toContain("Cannot update rotated secret");+ });-- expect(error!.message).toContain("Cannot update rotated secret");+ expect(await secretsAt("/services")).toEqual(secretsHolding(1));+ });++ test("Deleting a rotation with both flags set revokes the credentials and removes the secrets", async () => {+ const { secretRotation } = await newRotation("deletes-everything");+ const rotationId = secretRotation!.id;++ await rotateSecretRotation({ rotationId, authToken });++ await deleteSecretRotation({ rotationId, deleteSecrets: true, revokeGeneratedCredentials: true, authToken });++ // Both slots are revoked, not just the published one, so the previous credential cannot+ // outlive the rotation that issued it.+ expect(fakeIamUserSecret.keys()).toEqual({});+ expect(await secretsAt("/services")).toEqual({});+ expect(await listSecretRotations({ projectId, authToken })).toEqual([]);+ });++ test("Deleting a rotation with neither flag set leaves the credential live and the secrets editable", async () => {+ const { secretRotation } = await newRotation("leaves-everything");++ await deleteSecretRotation({+ rotationId: secretRotation!.id,+ deleteSecrets: false,+ revokeGeneratedCredentials: false,+ authToken+ });++ // The provider was never asked to revoke anything, so the credential still works. This is+ // the escape hatch for a rotation whose credential is in use elsewhere.+ expect(fakeIamUserSecret.keys()).toEqual(liveKeys(1));+ expect(await secretsAt("/services")).toEqual(secretsHolding(1));++ // Nothing owns the secrets now, so the write the rotation refused above succeeds.+ await updateSecretV2({+ workspaceId: projectId,+ environmentSlug: ENV,+ secretPath: "/services",+ key: SECRET_KEYS.accessKeyId,+ value: "hand-written-value",+ authToken+ });++ expect((await secretsAt("/services"))[SECRET_KEYS.accessKeyId]).toBe("hand-written-value");+ });+ });++ describe("A credential check reports what the provider says about the active credential", () => {+ test("A credential revoked at the provider fails the check", async () => {+ const { secretRotation } = await newRotation("check-credentials");+ const rotationId = secretRotation!.id;++ await checkRotationCredentials({ rotationId, authToken });++ fakeIamUserSecret.revokeOutOfBand(credential(1).accessKeyId);++ const error = await checkRotationCredentials({ rotationId, authToken, expectStatusCode: 400 });++ expect(error!.message).toContain(credential(1).accessKeyId);+ // The check reports, it does not repair: the rotation still holds the dead credential.+ expect(await secretsAt("/services")).toEqual(secretsHolding(1));+ });+ });+});diff --cc backend/src/server/routes/v1/app-connection-routers/app-connection-router.tsindex 0176cdecef,cbd408a9bd..3ba62f659a--- a/backend/src/server/routes/v1/app-connection-routers/app-connection-router.ts+++ b/backend/src/server/routes/v1/app-connection-routers/app-connection-router.ts@@@ -350,9 -353,9 +354,10 @@@ const SanitizedAppConnectionSchema = z....SanitizedLiteLLMConnectionSchema.options,...SanitizedFireworksConnectionSchema.options,...SanitizedNutanixPrismCentralConnectionSchema.options,+ ...SanitizedPowerDnsConnectionSchema.options,...SanitizedSpaceliftConnectionSchema.options,- ...SanitizedDaytonaConnectionSchema.options+ ...SanitizedDaytonaConnectionSchema.options,+ ...SanitizedStripeConnectionSchema.options]);const AppConnectionOptionsSchema = z.discriminatedUnion("app", [@@@ -438,9 -441,9 +443,10 @@@LiteLLMConnectionListItemSchema,FireworksConnectionListItemSchema,NutanixPrismCentralConnectionListItemSchema,+ PowerDnsConnectionListItemSchema,SpaceliftConnectionListItemSchema,- DaytonaConnectionListItemSchema+ DaytonaConnectionListItemSchema,+ StripeConnectionListItemSchema]);export const registerAppConnectionRouter = async (server: FastifyZodProvider) => {diff --cc backend/src/services/app-connection/app-connection-enums.tsindex eccea4851d,47daf35f48..dec249530e--- a/backend/src/services/app-connection/app-connection-enums.ts+++ b/backend/src/services/app-connection/app-connection-enums.ts@@@ -81,9 -81,9 +81,10 @@@ export enum AppConnectionKempLoadMaster = "kemp-loadmaster",MicrosoftIntune = "microsoft-intune",NutanixPrismCentral = "nutanix-prism-central",+ PowerDns = "powerdns",Spacelift = "spacelift",- Daytona = "daytona"+ Daytona = "daytona",+ Stripe = "stripe"}export enum AWSRegion {diff --cc backend/src/services/app-connection/app-connection-fns.tsindex 2e7e49f0c5,04167f1364..c7fb7ff12e--- a/backend/src/services/app-connection/app-connection-fns.ts+++ b/backend/src/services/app-connection/app-connection-fns.ts@@@ -427,9 -431,9 +433,10 @@@ export const listAppConnectionOptionsgetLiteLLMConnectionListItem(),getFireworksConnectionListItem(),getNutanixPrismCentralConnectionListItem(),+ getPowerDnsConnectionListItem(),getSpaceliftConnectionListItem(),- getDaytonaConnectionListItem()+ getDaytonaConnectionListItem(),+ getStripeConnectionListItem()].filter((option) => {switch (projectType) {@@@ -683,9 -687,9 +690,10 @@@ export const validateAppConnectionCrede[AppConnection.Fireworks]: validateFireworksConnectionCredentials as TAppConnectionCredentialsValidator,[AppConnection.NutanixPrismCentral]:validateNutanixPrismCentralConnectionCredentials as TAppConnectionCredentialsValidator,+ [AppConnection.PowerDns]: validatePowerDnsConnectionCredentials as TAppConnectionCredentialsValidator,[AppConnection.Spacelift]: validateSpaceliftConnectionCredentials as TAppConnectionCredentialsValidator,- [AppConnection.Daytona]: validateDaytonaConnectionCredentials as TAppConnectionCredentialsValidator+ [AppConnection.Daytona]: validateDaytonaConnectionCredentials as TAppConnectionCredentialsValidator,+ [AppConnection.Stripe]: validateStripeConnectionCredentials as TAppConnectionCredentialsValidator};return VALIDATE_APP_CONNECTION_CREDENTIALS_MAP[appConnection.app](appConnection, gatewayV2Service);@@@ -957,9 -961,9 +966,10 @@@ export const TRANSITION_CONNECTION_CRED[AppConnection.LiteLLM]: platformManagedCredentialsNotSupported,[AppConnection.Fireworks]: platformManagedCredentialsNotSupported,[AppConnection.NutanixPrismCentral]: platformManagedCredentialsNotSupported,+ [AppConnection.PowerDns]: platformManagedCredentialsNotSupported,[AppConnection.Spacelift]: platformManagedCredentialsNotSupported,- [AppConnection.Daytona]: platformManagedCredentialsNotSupported+ [AppConnection.Daytona]: platformManagedCredentialsNotSupported,+ [AppConnection.Stripe]: platformManagedCredentialsNotSupported};export const enterpriseAppCheck = async (diff --cc backend/src/services/app-connection/app-connection-maps.tsindex 4fc48d36dc,310c5b426b..e9fcc867fe--- a/backend/src/services/app-connection/app-connection-maps.ts+++ b/backend/src/services/app-connection/app-connection-maps.ts@@@ -82,10 -82,10 +82,11 @@@ export const APP_CONNECTION_NAME_MAP: R[AppConnection.LiteLLM]: "LiteLLM",[AppConnection.Fireworks]: "Fireworks",[AppConnection.NutanixPrismCentral]: "Nutanix Prism Central",+ [AppConnection.PowerDns]: "PowerDNS",[AppConnection.Spacelift]: "Spacelift",[AppConnection.Daytona]: "Daytona",- [AppConnection.MicrosoftIntune]: "Microsoft Intune"+ [AppConnection.MicrosoftIntune]: "Microsoft Intune",+ [AppConnection.Stripe]: "Stripe"};export const APP_CONNECTION_PLAN_MAP: Record<AppConnection, AppConnectionPlanType> = {@@@ -170,8 -170,8 +171,9 @@@[AppConnection.LiteLLM]: AppConnectionPlanType.Regular,[AppConnection.Fireworks]: AppConnectionPlanType.Regular,[AppConnection.NutanixPrismCentral]: AppConnectionPlanType.Regular,+ [AppConnection.PowerDns]: AppConnectionPlanType.Regular,[AppConnection.Spacelift]: AppConnectionPlanType.Regular,[AppConnection.Daytona]: AppConnectionPlanType.Regular,- [AppConnection.MicrosoftIntune]: AppConnectionPlanType.Enterprise+ [AppConnection.MicrosoftIntune]: AppConnectionPlanType.Enterprise,+ [AppConnection.Stripe]: AppConnectionPlanType.Regular};diff --cc backend/src/services/app-connection/app-connection-service.tsindex 3c3f7d5a19,3c1c9d7a5d..4c6bc05565--- a/backend/src/services/app-connection/app-connection-service.ts+++ b/backend/src/services/app-connection/app-connection-service.ts@@@ -305,9 -305,9 +306,10 @@@ const VALIDATE_APP_CONNECTION_CREDENTIA[AppConnection.LiteLLM]: ValidateLiteLLMConnectionCredentialsSchema,[AppConnection.Fireworks]: ValidateFireworksConnectionCredentialsSchema,[AppConnection.NutanixPrismCentral]: ValidateNutanixPrismCentralConnectionCredentialsSchema,+ [AppConnection.PowerDns]: ValidatePowerDnsConnectionCredentialsSchema,[AppConnection.Spacelift]: ValidateSpaceliftConnectionCredentialsSchema,- [AppConnection.Daytona]: ValidateDaytonaConnectionCredentialsSchema+ [AppConnection.Daytona]: ValidateDaytonaConnectionCredentialsSchema,+ [AppConnection.Stripe]: ValidateStripeConnectionCredentialsSchema};export const appConnectionServiceFactory = ({diff --cc backend/src/services/app-connection/app-connection-types.tsindex 37a661b2b9,7d613ab2c2..51857cfdbc--- a/backend/src/services/app-connection/app-connection-types.ts+++ b/backend/src/services/app-connection/app-connection-types.ts@@@ -588,9 -588,9 +594,10 @@@ export type TAppConnection = { id: stri| TLiteLLMConnection| TFireworksConnection| TNutanixPrismCentralConnection+ | TPowerDnsConnection| TSpaceliftConnection| TDaytonaConnection+ | TStripeConnection);export type TAppConnectionRaw = NonNullable<Awaited<ReturnType<TAppConnectionDALFactory["findById"]>>>;@@@ -684,9 -684,9 +691,10 @@@ export type TAppConnectionInput = { id| TLiteLLMConnectionInput| TFireworksConnectionInput| TNutanixPrismCentralConnectionInput+ | TPowerDnsConnectionInput| TSpaceliftConnectionInput| TDaytonaConnectionInput+ | TStripeConnectionInput);export type TSqlConnectionInput =@@@ -812,9 -812,9 +820,10 @@@ export type TAppConnectionConfig| TLiteLLMConnectionConfig| TFireworksConnectionConfig| TNutanixPrismCentralConnectionConfig+ | TPowerDnsConnectionConfig| TSpaceliftConnectionConfig- | TDaytonaConnectionConfig;+ | TDaytonaConnectionConfig+ | TStripeConnectionConfig;export type TValidateAppConnectionCredentialsSchema =| TValidateAwsConnectionCredentialsSchema@@@ -899,9 -899,9 +908,10 @@@| TValidateLiteLLMConnectionCredentialsSchema| TValidateFireworksConnectionCredentialsSchema| TValidateNutanixPrismCentralConnectionCredentialsSchema+ | TValidatePowerDnsConnectionCredentialsSchema| TValidateSpaceliftConnectionCredentialsSchema- | TValidateDaytonaConnectionCredentialsSchema;+ | TValidateDaytonaConnectionCredentialsSchema+ | TValidateStripeConnectionCredentialsSchema;export type TListAwsConnectionKmsKeys = {connectionId: string;diff --cc frontend/src/hooks/api/appConnections/types/index.tsindex 4eb6d35960,b985e67404..9df88a0039--- a/frontend/src/hooks/api/appConnections/types/index.ts+++ b/frontend/src/hooks/api/appConnections/types/index.ts@@@ -252,9 -252,9 +254,10 @@@ export type TAppConnection| TLiteLLMConnection| TFireworksConnection| TNutanixPrismCentralConnection+ | TPowerDnsConnection| TSpaceliftConnection- | TDaytonaConnection;+ | TDaytonaConnection+ | TStripeConnection;export type TAvailableAppConnection = Pick<TAppConnection, "name" | "id" | "projectId">;