fix: More release dep version refactor

apps/jobs/src/policy-checker/index.ts

@@ -41,7 +41,7 @@ export const run = async () => {
           schema.environmentPolicy.id,
         ),
         eq(
-          schema.environmentPolicyApproval.releaseId,
+          schema.environmentPolicyApproval.deploymentVersionId,
           schema.releaseJobTrigger.versionId,
         ),
       ),

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/checks/_components/flow-diagram/ApprovalCheck.tsx

@@ -6,12 +6,12 @@ import { Cancelled, Failing, Loading, Passing, Waiting } from "./StatusIcons";
 
 export const ApprovalCheck: React.FC<{
   policyId: string;
-  release: { id: string; version: string; deploymentId: string };
-}> = ({ policyId, release }) => {
+  deploymentVersion: { id: string; tag: string; deploymentId: string };
+}> = ({ policyId, deploymentVersion }) => {
   const approvalStatus =
-    api.environment.policy.approval.statusByReleasePolicyId.useQuery({
+    api.environment.policy.approval.statusByVersionPolicyId.useQuery({
       policyId,
-      releaseId: release.id,
+      versionId: deploymentVersion.id,
     });
 
   if (approvalStatus.isLoading)
@@ -50,7 +50,10 @@ export const ApprovalCheck: React.FC<{
       </div>
 
       {status === "pending" && (
-        <ApprovalDialog policyId={policyId} release={release}>
+        <ApprovalDialog
+          policyId={policyId}
+          deploymentVersion={deploymentVersion}
+        >
           <Button size="sm" className="h-6 px-2 py-1">
             Review
           </Button>

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/checks/_components/flow-diagram/EnvironmentNode.tsx

@@ -32,16 +32,16 @@ import { Cancelled, Failing, Loading, Passing, Waiting } from "./StatusIcons";
 type EnvironmentNodeProps = NodeProps<{
   workspaceId: string;
   policy?: SCHEMA.EnvironmentPolicy;
-  releaseId: string;
-  releaseVersion: string;
+  versionId: string;
+  versionTag: string;
   deploymentId: string;
   environmentId: string;
   environmentName: string;
 }>;
 
 const WaitingOnActiveCheck: React.FC<EnvironmentNodeProps["data"]> = ({
   workspaceId,
-  releaseId,
+  versionId,
   environmentId,
 }) => {
   const isSameEnvironment: EnvironmentCondition = {
@@ -65,7 +65,7 @@ const WaitingOnActiveCheck: React.FC<EnvironmentNodeProps["data"]> = ({
   const isSameRelease: JobReleaseCondition = {
     type: JobFilterType.Release,
     operator: ColumnOperator.Equals,
-    value: releaseId,
+    value: versionId,
   };
 
   const isDifferentRelease: JobCondition = {
@@ -135,14 +135,14 @@ const WaitingOnActiveCheck: React.FC<EnvironmentNodeProps["data"]> = ({
 const DeploymentVersionChannelCheck: React.FC<EnvironmentNodeProps["data"]> = ({
   deploymentId,
   environmentId,
-  releaseVersion,
+  versionTag,
 }) => {
   const { setDeploymentVersionChannelId } = useDeploymentVersionChannelDrawer();
   const {
     isPassingDeploymentVersionChannel,
     deploymentVersionChannelId,
     loading,
-  } = useDeploymentVersionChannel(deploymentId, environmentId, releaseVersion);
+  } = useDeploymentVersionChannel(deploymentId, environmentId, versionTag);
 
   return (
     <div className="flex items-center gap-2">

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/checks/_components/flow-diagram/FlowDiagram.tsx

@@ -23,17 +23,17 @@ const nodeTypes: NodeTypes = {
 export const FlowDiagram: React.FC<{
   workspace: SCHEMA.Workspace;
   systemId: string;
-  release: SCHEMA.DeploymentVersion;
+  deploymentVersion: SCHEMA.DeploymentVersion;
   envs: Array<SCHEMA.Environment>;
   policies: Array<SCHEMA.EnvironmentPolicy>;
   policyDeployments: Array<SCHEMA.EnvironmentPolicyDeployment>;
-}> = ({ workspace, release, envs, policies, policyDeployments }) => {
+}> = ({ workspace, deploymentVersion, envs, policies, policyDeployments }) => {
   const [nodes, _, onNodesChange] = useNodesState<{ label: string }>([
     {
       id: "trigger",
       type: "trigger",
       position: { x: 0, y: 0 },
-      data: { ...release, label: release.name },
+      data: { ...deploymentVersion, label: deploymentVersion.name },
     },
     ...policies.map((policy) => ({
       id: policy.id,
@@ -45,7 +45,7 @@ export const FlowDiagram: React.FC<{
           (p) => p.policyId === policy.id,
         ),
         label: policy.name,
-        release,
+        deploymentVersion,
       },
     })),
     ...envs.map((env) => {
@@ -56,9 +56,9 @@ export const FlowDiagram: React.FC<{
         position: { x: 0, y: 0 },
         data: {
           workspaceId: workspace.id,
-          releaseId: release.id,
-          releaseVersion: release.version,
-          deploymentId: release.deploymentId,
+          versionId: deploymentVersion.id,
+          versionTag: deploymentVersion.tag,
+          deploymentId: deploymentVersion.deploymentId,
           environmentId: env.id,
           environmentName: env.name,
           policy,

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/checks/_components/flow-diagram/FlowNode.tsx

@@ -11,13 +11,16 @@ import { JobStatus } from "@ctrlplane/validators/jobs";
 import { api } from "~/trpc/react";
 
 type EnvironmentNodeProps = NodeProps<
-  SCHEMA.Environment & { label: string; release: SCHEMA.DeploymentVersion }
+  SCHEMA.Environment & {
+    label: string;
+    deploymentVersion: SCHEMA.DeploymentVersion;
+  }
 >;
 
 export const EnvironmentNode: React.FC<EnvironmentNodeProps> = (node) => {
   const { data } = node;
-  const releaseJobTriggers = api.job.config.byReleaseId.useQuery(
-    { releaseId: data.release.id },
+  const releaseJobTriggers = api.job.config.byDeploymentVersionId.useQuery(
+    { versionId: data.deploymentVersion.id },
     { refetchInterval: 10_000 },
   );
   const environmentJobs = releaseJobTriggers.data?.filter(

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/checks/_components/flow-diagram/FlowPolicyNode.tsx

@@ -15,19 +15,19 @@ import { Cancelled, Loading, Passing, Waiting } from "./StatusIcons";
 
 type PolicyNodeProps = NodeProps<
   SCHEMA.EnvironmentPolicy & {
-    release: SCHEMA.DeploymentVersion;
+    deploymentVersion: SCHEMA.DeploymentVersion;
     policyDeployments: Array<SCHEMA.EnvironmentPolicyDeployment>;
   }
 >;
 
 const MinSuccessCheck: React.FC<PolicyNodeProps["data"]> = ({
   successMinimum,
   successType,
-  release,
+  deploymentVersion,
   policyDeployments,
 }) => {
-  const allJobs = api.job.config.byReleaseId.useQuery(
-    { releaseId: release.id },
+  const allJobs = api.job.config.byDeploymentVersionId.useQuery(
+    { versionId: deploymentVersion.id },
     { refetchInterval: 10_000 },
   );
   const envIds = policyDeployments.map((p) => p.environmentId);
@@ -71,15 +71,15 @@ const GradualRolloutCheck: React.FC<PolicyNodeProps["data"]> = (data) => {
   const [timeLeft, setTimeLeft] = useState<number | null>(null);
 
   const { data: approvalStatus, isLoading } =
-    api.environment.policy.approval.statusByReleasePolicyId.useQuery(
-      { policyId: data.id, releaseId: data.release.id },
+    api.environment.policy.approval.statusByVersionPolicyId.useQuery(
+      { policyId: data.id, versionId: data.deploymentVersion.id },
       { enabled: data.approvalRequirement === "manual" },
     );
 
   const startDate =
     data.approvalRequirement === "manual"
-      ? (approvalStatus?.approvedAt ?? data.release.createdAt)
-      : data.release.createdAt;
+      ? (approvalStatus?.approvedAt ?? data.deploymentVersion.createdAt)
+      : data.deploymentVersion.createdAt;
 
   useEffect(() => {
     const calculateTimeLeft = () => {
@@ -161,7 +161,10 @@ export const PolicyNode: React.FC<PolicyNodeProps> = ({ data }) => {
         {!noMinSuccess && <MinSuccessCheck {...data} />}
         {!noRollout && <GradualRolloutCheck {...data} />}
         {!noApproval && (
-          <ApprovalCheck policyId={data.id} release={data.release} />
+          <ApprovalCheck
+            policyId={data.id}
+            deploymentVersion={data.deploymentVersion}
+          />
         )}
 
         {noMinSuccess && noRollout && noApproval && (

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/checks/page.tsx

@@ -24,23 +24,25 @@ export async function generateMetadata(props: PageProps): Promise<Metadata> {
   const deployment = await api.deployment.bySlug(params);
   if (deployment == null) return notFound();
 
-  const release = await api.deployment.version.byId(params.releaseId);
-  if (release == null) return notFound();
+  const deploymentVersion = await api.deployment.version.byId(params.releaseId);
+  if (deploymentVersion == null) return notFound();
 
   return {
-    title: `${release.version} | ${deployment.name} | ${deployment.system.name} | ${deployment.system.workspace.name}`,
+    title: `${deploymentVersion.tag} | ${deployment.name} | ${deployment.system.name} | ${deployment.system.workspace.name}`,
   };
 }
 
 export default async function ChecksPage(props: PageProps) {
   const params = await props.params;
-  const releasePromise = api.deployment.version.byId(params.releaseId);
+  const deploymentVersionPromise = api.deployment.version.byId(
+    params.releaseId,
+  );
   const deploymentPromise = api.deployment.bySlug(params);
-  const [release, deployment] = await Promise.all([
-    releasePromise,
+  const [deploymentVersion, deployment] = await Promise.all([
+    deploymentVersionPromise,
     deploymentPromise,
   ]);
-  if (release == null || deployment == null) return notFound();
+  if (deploymentVersion == null || deployment == null) return notFound();
 
   const { system } = deployment;
   const environmentsPromise = api.environment.bySystemId(system.id);
@@ -64,7 +66,7 @@ export default async function ChecksPage(props: PageProps) {
       <ReactFlowProvider>
         <FlowDiagram
           workspace={system.workspace}
-          release={release}
+          deploymentVersion={deploymentVersion}
           envs={environments}
           systemId={system.id}
           policies={policies}

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/jobs/page.tsx

@@ -6,7 +6,6 @@ import { ResourceReleaseTable } from "./release-table/ResourceReleaseTable";
 
 type PageProps = {
   params: Promise<{
-    release: { id: string; version: string };
     workspaceSlug: string;
     systemSlug: string;
     deploymentSlug: string;
@@ -19,26 +18,26 @@ export async function generateMetadata(props: PageProps): Promise<Metadata> {
   const deployment = await api.deployment.bySlug(params);
   if (deployment == null) return notFound();
 
-  const release = await api.deployment.version.byId(params.releaseId);
-  if (release == null) return notFound();
+  const deploymentVersion = await api.deployment.version.byId(params.releaseId);
+  if (deploymentVersion == null) return notFound();
 
   return {
-    title: `${release.version} | ${deployment.name} | ${deployment.system.name} | ${deployment.system.workspace.name}`,
+    title: `${deploymentVersion.tag} | ${deployment.name} | ${deployment.system.name} | ${deployment.system.workspace.name}`,
   };
 }
 
 export default async function ReleasePage(props: PageProps) {
   const params = await props.params;
-  const release = await api.deployment.version.byId(params.releaseId);
+  const deploymentVersion = await api.deployment.version.byId(params.releaseId);
   const deployment = await api.deployment.bySlug(params);
-  if (release == null || deployment == null) notFound();
+  if (deploymentVersion == null || deployment == null) notFound();
 
   const { system } = deployment;
   const environments = await api.environment.bySystemId(system.id);
 
   return (
     <ResourceReleaseTable
-      release={release}
+      deploymentVersion={deploymentVersion}
       deployment={deployment}
       environments={environments}
     />

apps/webservice/src/app/[workspaceSlug]/(app)/(deploy)/(raw)/systems/[systemSlug]/(raw)/deployments/[deploymentSlug]/(raw)/releases/[releaseId]/jobs/release-table/EnvironmentApprovalRow.tsx

@@ -8,16 +8,19 @@ import { ApprovalDialog } from "~/app/[workspaceSlug]/(app)/(deploy)/_components
 
 type EnvironmentApprovalRowProps = {
   approval: EnvironmentPolicyApproval & { user?: User | null };
-  release: { id: string; version: string; deploymentId: string };
+  deploymentVersion: { id: string; tag: string; deploymentId: string };
 };
 
 export const EnvironmentApprovalRow: React.FC<EnvironmentApprovalRowProps> = ({
   approval,
-  release,
+  deploymentVersion,
 }) => {
   if (approval.status === "pending")
     return (
-      <ApprovalDialog release={release} policyId={approval.policyId}>
+      <ApprovalDialog
+        deploymentVersion={deploymentVersion}
+        policyId={approval.policyId}
+      >
         <Button size="sm" className="h-6">
           Review
         </Button>