feat: gradual rollouts

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

@@ -1,4 +1,7 @@
+import { alias, eq } from "@ctrlplane/db";
 import { db } from "@ctrlplane/db/client";
+import * as schema from "@ctrlplane/db/schema";
+import { Channel, getQueue } from "@ctrlplane/events";
 import { logger } from "@ctrlplane/logger";
 
 const triggerPolicyEvaluation = async () => {
@@ -11,10 +14,27 @@ const triggerPolicyEvaluation = async () => {
 
   while (hasMore) {
     try {
-      const releaseTargets = await db.query.releaseTarget.findMany({
-        limit: PAGE_SIZE,
-        offset,
-      });
+      const ct = alias(schema.computedPolicyTargetReleaseTarget, "ct");
+
+      const releaseTargets = await db
+        .select()
+        .from(schema.policy)
+        .innerJoin(
+          schema.policyTarget,
+          eq(schema.policyTarget.policyId, schema.policy.id),
+        )
+        .innerJoin(ct, eq(ct.policyTargetId, schema.policyTarget.id))
+        .innerJoin(
+          schema.releaseTarget,
+          eq(ct.releaseTargetId, schema.releaseTarget.id),
+        )
+        .innerJoin(
+          schema.policyRuleGradualRollout,
+          eq(schema.policyRuleGradualRollout.policyId, schema.policy.id),
+        )
+        .limit(PAGE_SIZE)
+        .offset(offset)
+        .then((rows) => rows.map((row) => row.release_target));
 
       if (releaseTargets.length === 0) {
         hasMore = false;
@@ -26,15 +46,15 @@ const triggerPolicyEvaluation = async () => {
       );
       totalProcessed += releaseTargets.length;
 
-      // await getQueue(Channel.EvaluateReleaseTarget).addBulk(
-      //   releaseTargets.map((rt) => ({
-      //     name: `${rt.resourceId}-${rt.environmentId}-${rt.deploymentId}`,
-      //     data: rt,
-      //     priority: 10,
-      //   })),
-      // );
-
       offset += PAGE_SIZE;
+
+      await getQueue(Channel.EvaluateReleaseTarget).addBulk(
+        releaseTargets.map((rt) => ({
+          name: `${rt.resourceId}-${rt.environmentId}-${rt.deploymentId}`,
+          data: rt,
+          priority: 10,
+        })),
+      );
     } catch (error) {
       logger.error("Error during policy evaluation:", error);
       throw error;

apps/webservice/src/app/api/v1/deployment-versions/[deploymentVersionId]/releases/openapi.ts

@@ -0,0 +1,79 @@
+import type { Swagger } from "atlassian-openapi";
+
+export const openapi: Swagger.SwaggerV3 = {
+  openapi: "3.0.0",
+  info: {
+    title: "Ctrlplane API",
+    version: "1.0.0",
+  },
+  components: {
+    schemas: {
+      Release: {
+        type: "object",
+        properties: {
+          resource: { $ref: "#/components/schemas/Resource" },
+          environment: { $ref: "#/components/schemas/Environment" },
+          deployment: { $ref: "#/components/schemas/Deployment" },
+          version: { $ref: "#/components/schemas/DeploymentVersion" },
+          variables: { type: "object", additionalProperties: true },
+        },
+      },
+    },
+  },
+  paths: {
+    "/v1/deployment-versions/{deploymentVersionId}/releases": {
+      get: {
+        summary: "Get all releases for a deployment version",
+        parameters: [
+          {
+            name: "deploymentVersionId",
+            in: "path",
+            required: true,
+            schema: { type: "string", format: "uuid" },
+          },
+        ],
+        responses: {
+          200: {
+            description: "OK",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "array",
+                  items: { $ref: "#/components/schemas/Release" },
+                },
+              },
+            },
+          },
+          404: {
+            description: "Not Found",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    error: { type: "string" },
+                  },
+                  required: ["error"],
+                },
+              },
+            },
+          },
+          500: {
+            description: "Internal Server Error",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    error: { type: "string" },
+                  },
+                  required: ["error"],
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};

apps/webservice/src/app/api/v1/deployment-versions/[deploymentVersionId]/releases/route.ts

@@ -0,0 +1,113 @@
+import type { Tx } from "@ctrlplane/db";
+import { NextResponse } from "next/server";
+import { NOT_FOUND } from "http-status";
+
+import { eq, sql } from "@ctrlplane/db";
+import * as SCHEMA from "@ctrlplane/db/schema";
+import { Permission } from "@ctrlplane/validators/auth";
+
+import { authn, authz } from "~/app/api/v1/auth";
+import { request } from "~/app/api/v1/middleware";
+
+export const GET = request()
+  .use(authn)
+  .use(
+    authz(({ can, params }) =>
+      can.perform(Permission.DeploymentVersionGet).on({
+        type: "deploymentVersion",
+        id: params.deploymentVersionId ?? "",
+      }),
+    ),
+  )
+  .handle<{ db: Tx }, { params: Promise<{ deploymentVersionId: string }> }>(
+    async ({ db }, { params }) => {
+      const { deploymentVersionId } = await params;
+
+      const deploymentVersion = await db.query.deploymentVersion.findFirst({
+        where: eq(SCHEMA.deploymentVersion.id, deploymentVersionId),
+        with: { metadata: true },
+      });
+
+      if (deploymentVersion == null)
+        return NextResponse.json(
+          { error: "Deployment version not found" },
+          { status: NOT_FOUND },
+        );
+
+      const variableReleaseSubquery = db
+        .select({
+          variableSetReleaseId: SCHEMA.variableSetRelease.id,
+          variables: sql<Record<string, any>>`COALESCE(jsonb_object_agg(
+          ${SCHEMA.variableValueSnapshot.key},
+          ${SCHEMA.variableValueSnapshot.value}
+        ) FILTER (WHERE ${SCHEMA.variableValueSnapshot.id} IS NOT NULL), '{}'::jsonb)`.as(
+            "variables",
+          ),
+        })
+        .from(SCHEMA.variableSetRelease)
+        .leftJoin(
+          SCHEMA.variableSetReleaseValue,
+          eq(
+            SCHEMA.variableSetRelease.id,
+            SCHEMA.variableSetReleaseValue.variableSetReleaseId,
+          ),
+        )
+        .leftJoin(
+          SCHEMA.variableValueSnapshot,
+          eq(
+            SCHEMA.variableSetReleaseValue.variableValueSnapshotId,
+            SCHEMA.variableValueSnapshot.id,
+          ),
+        )
+        .groupBy(SCHEMA.variableSetRelease.id)
+        .as("variableRelease");
+
+      const releases = await db
+        .select()
+        .from(SCHEMA.release)
+        .innerJoin(
+          SCHEMA.versionRelease,
+          eq(SCHEMA.release.versionReleaseId, SCHEMA.versionRelease.id),
+        )
+        .innerJoin(
+          variableReleaseSubquery,
+          eq(
+            SCHEMA.release.variableReleaseId,
+            variableReleaseSubquery.variableSetReleaseId,
+          ),
+        )
+        .innerJoin(
+          SCHEMA.releaseTarget,
+          eq(SCHEMA.versionRelease.releaseTargetId, SCHEMA.releaseTarget.id),
+        )
+        .innerJoin(
+          SCHEMA.resource,
+          eq(SCHEMA.releaseTarget.resourceId, SCHEMA.resource.id),
+        )
+        .innerJoin(
+          SCHEMA.environment,
+          eq(SCHEMA.releaseTarget.environmentId, SCHEMA.environment.id),
+        )
+        .innerJoin(
+          SCHEMA.deployment,
+          eq(SCHEMA.releaseTarget.deploymentId, SCHEMA.deployment.id),
+        )
+        .where(eq(SCHEMA.versionRelease.versionId, deploymentVersionId))
+        .limit(500);
+
+      const fullReleases = releases.map((release) => ({
+        resource: release.resource,
+        environment: release.environment,
+        deployment: release.deployment,
+        version: {
+          ...deploymentVersion,
+          metadata: Object.fromEntries(
+            deploymentVersion.metadata.map((m) => [m.key, m.value]),
+          ),
+        },
+        variables: release.variableRelease.variables,
+      }));
+
+      return NextResponse.json(fullReleases);
+    },
+  );

apps/webservice/src/app/api/v1/policies/[policyId]/openapi.ts

@@ -77,6 +77,10 @@ export const openapi: Swagger.SwaggerV3 = {
                       required: ["roleId"],
                     },
                   },
+                  gradualRollout: {
+                    $ref: "#/components/schemas/GradualRollout",
+                    nullable: true,
+                  },
                 },
               },
             },

apps/webservice/src/app/api/v1/policies/openapi.ts

@@ -67,6 +67,16 @@ export const openapi: Swagger.SwaggerV3 = {
         },
         required: ["roleId", "requiredApprovalsCount"],
       },
+      GradualRollout: {
+        type: "object",
+        properties: {
+          deployRate: { type: "number" },
+          windowSizeMinutes: { type: "number" },
+          name: { type: "string" },
+          description: { type: "string" },
+        },
+        required: ["deployRate", "windowSizeMinutes", "name"],
+      },
       Policy: {
         type: "object",
         properties: {
@@ -99,6 +109,10 @@ export const openapi: Swagger.SwaggerV3 = {
             type: "array",
             items: { $ref: "#/components/schemas/VersionRoleApproval" },
           },
+          gradualRollout: {
+            $ref: "#/components/schemas/GradualRollout",
+            nullable: true,
+          },
         },
         required: [
           "id",
@@ -111,6 +125,7 @@ export const openapi: Swagger.SwaggerV3 = {
           "denyWindows",
           "versionUserApprovals",
           "versionRoleApprovals",
+          "gradualRollout",
         ],
       },
     },
@@ -166,6 +181,9 @@ export const openapi: Swagger.SwaggerV3 = {
                       $ref: "#/components/schemas/VersionRoleApproval",
                     },
                   },
+                  gradualRollout: {
+                    $ref: "#/components/schemas/GradualRollout",
+                  },
                 },
                 required: ["name", "workspaceId", "targets"],
               },