dify/web/features/deployments/create-guide/state/submission.ts

'use client'

import type { DeployRequest } from '@dify/contracts/enterprise/types.gen'
import { atom } from 'jotai'
import { atomWithMutation } from 'jotai-tanstack-query'
import { selectedDeploymentRuntimeCredentials } from '@/features/deployments/shared/components/runtime-credential-bindings-utils'
import { encodeDslContent, isWorkflowDsl } from '@/features/deployments/shared/domain/dsl'
import { unsupportedDslNodeError } from '@/features/deployments/shared/domain/error'
import { createDeploymentIdempotencyKey } from '@/features/deployments/shared/domain/idempotency'
import { consoleQuery } from '@/service/client'
import { environmentMatchesIdentifier } from './environment'
import {
  effectiveMethodAtom,
  envVarValuesAtom,
  instanceDescriptionAtom,
  instanceNameAtom,
  isCreatingDeploymentAtom,
  isCreatingReleaseOnlyAtom,
  isSubmittingDeploymentGuideAtom,
  releaseDescriptionAtom,
  releaseNameAtom,
  selectedEnvironmentIdAtom,
  submissionUnsupportedDslNodesAtom,
} from './primitives'
import { deployableEnvironmentsQueryAtom, deploymentOptionsDataAtom } from './queries'
import { submittedReleaseReadyAtom } from './release'
import { dslContentAtom, effectiveSelectedAppAtom } from './source'
import {
  canDeployAtom,
  canSkipDeploymentAtom,
  deployableEnvironmentsAtom,
  deploymentTargetBindingSelectionsAtom,
  deploymentTargetBindingSlotsAtom,
  deploymentTargetEnvVarSlotsAtom,
  requiredBindingsReadyAtom,
  requiredEnvVarsReadyAtom,
} from './target'
import { envVarInput } from './utils'

const createAppInstanceMutationAtom = atomWithMutation(() =>
  consoleQuery.enterprise.appInstanceService.createAppInstance.mutationOptions(),
)

const createReleaseMutationAtom = atomWithMutation(() =>
  consoleQuery.enterprise.releaseService.createRelease.mutationOptions(),
)

const createInitialDeploymentMutationAtom = atomWithMutation(() =>
  consoleQuery.enterprise.deploymentService.deploy.mutationOptions(),
)

export class CreateDeploymentGuideSubmissionBlockedError extends Error {
  reason: 'unsupportedDslMode' | 'deployFailed'

  constructor(reason: 'unsupportedDslMode' | 'deployFailed') {
    super(reason)
    this.reason = reason
    this.name = 'CreateDeploymentGuideSubmissionBlockedError'
  }
}

export const createDeploymentGuideSubmissionAtom = atom(null, async (get, set, {
  deployToEnvironment,
}: {
  deployToEnvironment: boolean
}) => {
  const method = get(effectiveMethodAtom)
  const dslContent = get(dslContentAtom)
  const submittedInstanceName = get(instanceNameAtom).trim()
  const submittedReleaseName = get(releaseNameAtom).trim()
  const submittedReleaseDescription = get(releaseDescriptionAtom).trim()

  if (get(isSubmittingDeploymentGuideAtom) || !get(submittedReleaseReadyAtom))
    return undefined

  const effectiveSelectedApp = get(effectiveSelectedAppAtom)
  const deployableEnvironmentsQuery = get(deployableEnvironmentsQueryAtom)
  const deploymentOptions = get(deploymentOptionsDataAtom)?.options
  const envVarSlots = get(deploymentTargetEnvVarSlotsAtom)
  const envVarValues = get(envVarValuesAtom)
  const bindingSlots = get(deploymentTargetBindingSlotsAtom)
  const bindingSelections = get(deploymentTargetBindingSelectionsAtom)
  const selectedEnvironmentId = get(selectedEnvironmentIdAtom)
  const effectiveSelectedEnvironmentId = selectedEnvironmentId || get(deployableEnvironmentsAtom)[0]?.id
  const selectedEnvironment = effectiveSelectedEnvironmentId
    ? get(deployableEnvironmentsAtom).find(env => environmentMatchesIdentifier(env, effectiveSelectedEnvironmentId))
    : undefined

  if (deployToEnvironment && !selectedEnvironment && !selectedEnvironmentId.trim())
    return undefined
  if (method === 'bindApp' && !effectiveSelectedApp?.id)
    return undefined
  if (method === 'importDsl' && !dslContent.trim())
    return undefined
  if (method === 'importDsl' && !isWorkflowDsl(dslContent))
    throw new CreateDeploymentGuideSubmissionBlockedError('unsupportedDslMode')

  set(submissionUnsupportedDslNodesAtom, [])

  try {
    if (!deployToEnvironment) {
      if (!get(canSkipDeploymentAtom))
        return undefined

      set(isCreatingReleaseOnlyAtom, true)

      try {
        const createdAppInstance = await get(createAppInstanceMutationAtom).mutateAsync({
          body: {
            displayName: submittedInstanceName,
            description: get(instanceDescriptionAtom).trim() || undefined,
          },
        })
        const appInstanceId = createdAppInstance.appInstance.id

        if (method === 'importDsl') {
          await get(createReleaseMutationAtom).mutateAsync({
            body: {
              appInstanceId,
              dsl: encodeDslContent(dslContent),
              displayName: submittedReleaseName,
              description: submittedReleaseDescription || undefined,
              createAppInstance: false,
            },
          })

          return appInstanceId
        }

        if (!effectiveSelectedApp?.id)
          return undefined

        await get(createReleaseMutationAtom).mutateAsync({
          body: {
            appInstanceId,
            sourceAppId: effectiveSelectedApp.id,
            displayName: submittedReleaseName,
            description: submittedReleaseDescription || undefined,
            createAppInstance: false,
          },
        })

        return appInstanceId
      }
      finally {
        set(isCreatingReleaseOnlyAtom, false)
      }
    }

    if (!get(canDeployAtom))
      return undefined

    set(isCreatingDeploymentAtom, true)

    try {
      const selectedEnvironmentIdentifier = selectedEnvironmentId.trim()
      const freshSelectedEnvironment = selectedEnvironment || (
        selectedEnvironmentIdentifier
          ? (await deployableEnvironmentsQuery.refetch()).data?.environments.find(environment =>
              environmentMatchesIdentifier(environment, selectedEnvironmentIdentifier),
            )
          : undefined
      )
      const targetEnvironmentId = freshSelectedEnvironment?.id
      if (!targetEnvironmentId)
        throw new CreateDeploymentGuideSubmissionBlockedError('deployFailed')

      if (!get(requiredBindingsReadyAtom))
        throw new Error('Missing required deployment binding.')
      if (!get(requiredEnvVarsReadyAtom))
        throw new Error('Missing required deployment environment variable.')

      const envVars = envVarSlots.flatMap(slot => envVarInput(slot, envVarValues[slot.key]))
      const commonDeploymentRequest = {
        newAppInstance: {
          displayName: submittedInstanceName,
          description: get(instanceDescriptionAtom).trim() || undefined,
        },
        environmentId: targetEnvironmentId,
        releaseName: submittedReleaseName,
        releaseDescription: submittedReleaseDescription || undefined,
        credentials: selectedDeploymentRuntimeCredentials(bindingSlots, bindingSelections),
        envVars,
        idempotencyKey: createDeploymentIdempotencyKey(),
        expectedDslDigest: deploymentOptions?.dslDigest,
      } satisfies Omit<DeployRequest, 'dsl' | 'sourceAppId'>
      const deploymentRequest = method === 'importDsl'
        ? {
            ...commonDeploymentRequest,
            dsl: encodeDslContent(dslContent),
          }
        : effectiveSelectedApp?.id
          ? {
              ...commonDeploymentRequest,
              sourceAppId: effectiveSelectedApp.id,
            }
          : undefined
      if (!deploymentRequest)
        return undefined

      const response = await get(createInitialDeploymentMutationAtom).mutateAsync({
        body: deploymentRequest,
      })

      return response.appInstance.id
    }
    finally {
      set(isCreatingDeploymentAtom, false)
    }
  }
  catch (error) {
    const unsupportedError = await unsupportedDslNodeError(error)
    if (unsupportedError?.nodes.length) {
      set(submissionUnsupportedDslNodesAtom, unsupportedError.nodes)

      return undefined
    }

    throw error
  }
})