chore: release target state api endpoint

Author: adityachoudhari26

apps/api/openapi/openapi.json

@@ -1134,6 +1134,20 @@
             ],
             "type": "object"
          },
+         "ReleaseTargetState": {
+            "properties": {
+               "currentRelease": {
+                  "$ref": "#/components/schemas/Release"
+               },
+               "desiredRelease": {
+                  "$ref": "#/components/schemas/Release"
+               },
+               "latestJob": {
+                  "$ref": "#/components/schemas/Job"
+               }
+            },
+            "type": "object"
+         },
          "Resource": {
             "properties": {
                "config": {
@@ -4615,6 +4629,74 @@
             "summary": "Get jobs for a release target"
          }
       },
+      "/v1/workspaces/{workspaceId}/release-targets/{releaseTargetKey}/state": {
+         "get": {
+            "description": "Returns the state for a release target {releaseTargetKey}.",
+            "operationId": "getReleaseTargetState",
+            "parameters": [
+               {
+                  "description": "ID of the workspace",
+                  "in": "path",
+                  "name": "workspaceId",
+                  "required": true,
+                  "schema": {
+                     "type": "string"
+                  }
+               },
+               {
+                  "description": "Key of the release target",
+                  "in": "path",
+                  "name": "releaseTargetKey",
+                  "required": true,
+                  "schema": {
+                     "type": "string"
+                  }
+               },
+               {
+                  "description": "Whether to bypass the cache",
+                  "in": "query",
+                  "name": "bypassCache",
+                  "required": false,
+                  "schema": {
+                     "type": "boolean"
+                  }
+               }
+            ],
+            "responses": {
+               "200": {
+                  "content": {
+                     "application/json": {
+                        "schema": {
+                           "$ref": "#/components/schemas/ReleaseTargetState"
+                        }
+                     }
+                  },
+                  "description": "The state for the release target"
+               },
+               "400": {
+                  "content": {
+                     "application/json": {
+                        "schema": {
+                           "$ref": "#/components/schemas/ErrorResponse"
+                        }
+                     }
+                  },
+                  "description": "Invalid request"
+               },
+               "404": {
+                  "content": {
+                     "application/json": {
+                        "schema": {
+                           "$ref": "#/components/schemas/ErrorResponse"
+                        }
+                     }
+                  },
+                  "description": "Resource not found"
+               }
+            },
+            "summary": "Get the state for a release target"
+         }
+      },
       "/v1/workspaces/{workspaceId}/releases/{releaseId}": {
          "get": {
             "description": "Returns a specific release by ID.",

apps/api/openapi/paths/release-targets.jsonnet

@@ -37,4 +37,26 @@ local openapi = import '../lib/openapi.libsonnet';
       ) + openapi.notFoundResponse(),
     },
   },
+  '/v1/workspaces/{workspaceId}/release-targets/{releaseTargetKey}/state': {
+    get: {
+      summary: 'Get the state for a release target',
+      operationId: 'getReleaseTargetState',
+      description: 'Returns the state for a release target {releaseTargetKey}.',
+      parameters: [
+        openapi.workspaceIdParam(),
+        openapi.releaseTargetKeyParam(),
+        {
+          name: 'bypassCache',
+          'in': 'query',
+          description: 'Whether to bypass the cache',
+          schema: { type: 'boolean' },
+          required: false,
+        },
+      ],
+      responses: openapi.okResponse(
+        openapi.schemaRef('ReleaseTargetState'),
+        'The state for the release target',
+      ) + openapi.notFoundResponse() + openapi.badRequestResponse(),
+    },
+  },
 }

apps/api/openapi/schemas/release.jsonnet

@@ -28,4 +28,12 @@ local openapi = import '../lib/openapi.libsonnet';
       createdAt: { type: 'string' },
     },
   },
+  ReleaseTargetState: {
+    type: 'object',
+    properties: {
+      desiredRelease: openapi.schemaRef('Release'),
+      currentRelease: openapi.schemaRef('Release'),
+      latestJob: openapi.schemaRef('Job'),
+    },
+  },
 }

apps/api/src/routes/v1/workspaces/release-targets.ts

@@ -48,9 +48,33 @@ const getReleaseTargetDesiredRelease: AsyncTypedHandler<
   res.status(200).json(desiredReleaseResponse.data);
 };
 
+const getReleaseTargetState: AsyncTypedHandler<
+  "/v1/workspaces/{workspaceId}/release-targets/{releaseTargetKey}/state",
+  "get"
+> = async (req, res) => {
+  const { workspaceId, releaseTargetKey } = req.params;
+  const { bypassCache } = req.query;
+
+  const stateResponse = await getClientFor(workspaceId).GET(
+    "/v1/workspaces/{workspaceId}/release-targets/{releaseTargetKey}/state",
+    {
+      params: {
+        path: { workspaceId, releaseTargetKey },
+        query: { bypassCache },
+      },
+    },
+  );
+
+  if (stateResponse.error != null)
+    throw new ApiError(stateResponse.error.error ?? "Unknown error", 500);
+
+  res.status(200).json(stateResponse.data);
+};
+
 const releaseTargetKeyRouter = Router({ mergeParams: true })
   .get("/jobs", asyncHandler(getReleaseTargetJobs))
-  .get("/desired-release", asyncHandler(getReleaseTargetDesiredRelease));
+  .get("/desired-release", asyncHandler(getReleaseTargetDesiredRelease))
+  .get("/state", asyncHandler(getReleaseTargetState));
 
 export const releaseTargetsRouter = Router({ mergeParams: true }).use(
   "/:releaseTargetKey",

apps/api/src/types/openapi.ts

@@ -513,6 +513,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/workspaces/{workspaceId}/release-targets/{releaseTargetKey}/state": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get the state for a release target
+         * @description Returns the state for a release target {releaseTargetKey}.
+         */
+        get: operations["getReleaseTargetState"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/workspaces/{workspaceId}/releases/{releaseId}": {
         parameters: {
             query?: never;
@@ -1027,6 +1047,11 @@ export interface components {
             environmentId: string;
             resourceId: string;
         };
+        ReleaseTargetState: {
+            currentRelease?: components["schemas"]["Release"];
+            desiredRelease?: components["schemas"]["Release"];
+            latestJob?: components["schemas"]["Job"];
+        };
         Resource: {
             config: {
                 [key: string]: unknown;
@@ -3116,6 +3141,52 @@ export interface operations {
             };
         };
     };
+    getReleaseTargetState: {
+        parameters: {
+            query?: {
+                /** @description Whether to bypass the cache */
+                bypassCache?: boolean;
+            };
+            header?: never;
+            path: {
+                /** @description ID of the workspace */
+                workspaceId: string;
+                /** @description Key of the release target */
+                releaseTargetKey: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The state for the release target */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ReleaseTargetState"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Resource not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     getRelease: {
         parameters: {
             query?: never;

packages/workspace-engine-sdk/src/schema.ts

@@ -718,6 +718,26 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
+  "/v1/workspaces/{workspaceId}/release-targets/{releaseTargetKey}/state": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get the state for a release target
+     * @description Returns the state for a release target {releaseTargetKey}.
+     */
+    get: operations["getReleaseTargetState"];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/v1/workspaces/{workspaceId}/releases/{releaseId}": {
     parameters: {
       query?: never;
@@ -3192,6 +3212,43 @@ export interface operations {
       };
     };
   };
+  getReleaseTargetState: {
+    parameters: {
+      query?: {
+        /** @description Whether to bypass the cache */
+        bypassCache?: boolean;
+      };
+      header?: never;
+      path: {
+        /** @description ID of the workspace */
+        workspaceId: string;
+        /** @description Key of the release target */
+        releaseTargetKey: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description The state for the release target */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["ReleaseTargetState"];
+        };
+      };
+      /** @description Resource not found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["ErrorResponse"];
+        };
+      };
+    };
+  };
   getRelease: {
     parameters: {
       query?: never;