chore: resource variable router

Author: adityachoudhari26

apps/api/openapi/openapi.json

@@ -1263,6 +1263,25 @@
             ],
             "type": "object"
          },
+         "ResourceVariable": {
+            "properties": {
+               "key": {
+                  "type": "string"
+               },
+               "resourceId": {
+                  "type": "string"
+               },
+               "value": {
+                  "$ref": "#/components/schemas/Value"
+               }
+            },
+            "required": [
+               "resourceId",
+               "key",
+               "value"
+            ],
+            "type": "object"
+         },
          "Selector": {
             "oneOf": [
                {
@@ -4969,6 +4988,117 @@
             ]
          }
       },
+      "/v1/workspaces/{workspaceId}/resources/identifier/{identifier}/variables": {
+         "get": {
+            "description": "Returns a list of variables for a resource",
+            "operationId": "getVariablesForResource",
+            "parameters": [
+               {
+                  "description": "ID of the workspace",
+                  "in": "path",
+                  "name": "workspaceId",
+                  "required": true,
+                  "schema": {
+                     "type": "string"
+                  }
+               },
+               {
+                  "description": "Identifier of the resource",
+                  "in": "path",
+                  "name": "identifier",
+                  "required": true,
+                  "schema": {
+                     "type": "string"
+                  }
+               },
+               {
+                  "description": "Maximum number of items to return",
+                  "in": "query",
+                  "name": "limit",
+                  "required": false,
+                  "schema": {
+                     "default": 50,
+                     "maximum": 1000,
+                     "minimum": 1,
+                     "type": "integer"
+                  }
+               },
+               {
+                  "description": "Number of items to skip",
+                  "in": "query",
+                  "name": "offset",
+                  "required": false,
+                  "schema": {
+                     "default": 0,
+                     "minimum": 0,
+                     "type": "integer"
+                  }
+               }
+            ],
+            "responses": {
+               "200": {
+                  "content": {
+                     "application/json": {
+                        "schema": {
+                           "properties": {
+                              "items": {
+                                 "items": {
+                                    "$ref": "#/components/schemas/ResourceVariable"
+                                 },
+                                 "type": "array"
+                              },
+                              "limit": {
+                                 "description": "Maximum number of items returned",
+                                 "type": "integer"
+                              },
+                              "offset": {
+                                 "description": "Number of items skipped",
+                                 "type": "integer"
+                              },
+                              "total": {
+                                 "description": "Total number of items available",
+                                 "type": "integer"
+                              }
+                           },
+                           "required": [
+                              "items",
+                              "total",
+                              "limit",
+                              "offset"
+                           ],
+                           "type": "object"
+                        }
+                     }
+                  },
+                  "description": "The requested variables"
+               },
+               "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 variables for a resource",
+            "tags": [
+               "Resources"
+            ]
+         }
+      },
       "/v1/workspaces/{workspaceId}/systems": {
          "get": {
             "operationId": "listSystems",

apps/api/openapi/paths/resources.jsonnet

@@ -30,4 +30,21 @@ local openapi = import '../lib/openapi.libsonnet';
       responses: openapi.okResponse(openapi.schemaRef('Resource')),
     },
   },
+  '/v1/workspaces/{workspaceId}/resources/identifier/{identifier}/variables': {
+    get: {
+      tags: ['Resources'],
+      summary: 'Get variables for a resource',
+      operationId: 'getVariablesForResource',
+      description: 'Returns a list of variables for a resource',
+      parameters: [
+        openapi.workspaceIdParam(),
+        openapi.identifierParam(),
+        openapi.limitParam(),
+        openapi.offsetParam(),
+      ],
+      responses: openapi.paginatedResponse(openapi.schemaRef('ResourceVariable'), 'The requested variables') + 
+        openapi.notFoundResponse() + 
+        openapi.badRequestResponse(),
+    },
+  }
 }

apps/api/openapi/schemas/resources.jsonnet

@@ -1,3 +1,5 @@
+local openapi = import '../lib/openapi.libsonnet';
+
 {
   Resource: {
     type: 'object',
@@ -32,4 +34,13 @@
       },
     },
   },
+    ResourceVariable: {
+    type: 'object',
+    required: ['resourceId', 'key', 'value'],
+    properties: {
+      resourceId: { type: 'string' },
+      key: { type: 'string' },
+      value: openapi.schemaRef('Value'),
+    },
+  },
 }

apps/api/src/routes/v1/workspaces/index.ts

@@ -19,7 +19,7 @@ import { relationshipRulesRouter } from "./relationship-rules.js";
 import { releaseTargetsRouter } from "./release-targets.js";
 import { releaseRouter } from "./releases.js";
 import { resourceProvidersRouter } from "./resource-providers.js";
-import { listResources } from "./resources.js";
+import { resourceRouter } from "./resources.js";
 import { systemRouter } from "./systems.js";
 
 /**
@@ -33,7 +33,7 @@ export const createWorkspacesRouter = (): Router =>
     .get("/:workspaceId", asyncHandler(getWorkspace))
     .patch("/:workspaceId", asyncHandler(updateWorkspace))
     .delete("/:workspaceId", asyncHandler(deleteWorkspace))
-    .get("/:workspaceId/resources", asyncHandler(listResources))
+    .use("/:workspaceId/resources", resourceRouter)
     .use("/:workspaceId/systems", systemRouter)
     .use("/:workspaceId/resource-providers", resourceProvidersRouter)
     .use("/:workspaceId/deployments", deploymentsRouter)

apps/api/src/routes/v1/workspaces/resources.ts

@@ -1,8 +1,10 @@
 import type { AsyncTypedHandler } from "@/types/api.js";
+import { ApiError, asyncHandler } from "@/types/api.js";
+import { Router } from "express";
 
 import { getClientFor } from "@ctrlplane/workspace-engine-sdk";
 
-export const listResources: AsyncTypedHandler<
+const listResources: AsyncTypedHandler<
   "/v1/workspaces/{workspaceId}/resources",
   "get"
 > = async (req, res) => {
@@ -33,7 +35,7 @@ export const listResources: AsyncTypedHandler<
   res.status(200).json(result.data);
 };
 
-export const getResourceByIdentifier: AsyncTypedHandler<
+const getResourceByIdentifier: AsyncTypedHandler<
   "/v1/workspaces/{workspaceId}/resources/identifier/{identifier}",
   "get"
 > = async (req, res) => {
@@ -51,3 +53,32 @@ export const getResourceByIdentifier: AsyncTypedHandler<
 
   res.status(200).json(result.data);
 };
+
+const getVariablesForResource: AsyncTypedHandler<
+  "/v1/workspaces/{workspaceId}/resources/identifier/{identifier}/variables",
+  "get"
+> = async (req, res) => {
+  const { workspaceId, identifier } = req.params;
+  const { limit, offset } = req.query;
+
+  const result = await getClientFor(workspaceId).GET(
+    "/v1/workspaces/{workspaceId}/resources/{resourceIdentifier}/variables",
+    {
+      params: { path: { workspaceId, resourceIdentifier: identifier } },
+      query: { limit, offset },
+    },
+  );
+
+  if (result.error != null)
+    throw new ApiError(
+      result.error.error ?? "Failed to get variables for resource",
+      500,
+    );
+
+  res.status(200).json(result.data);
+};
+
+export const resourceRouter = Router({ mergeParams: true })
+  .get("/", asyncHandler(listResources))
+  .get("/:identifier", asyncHandler(getResourceByIdentifier))
+  .get("/:identifier/variables", asyncHandler(getVariablesForResource));

apps/api/src/types/openapi.ts

@@ -625,6 +625,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/workspaces/{workspaceId}/resources/identifier/{identifier}/variables": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get variables for a resource
+         * @description Returns a list of variables for a resource
+         */
+        get: operations["getVariablesForResource"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/workspaces/{workspaceId}/systems": {
         parameters: {
             query?: never;
@@ -1057,6 +1077,11 @@ export interface components {
             updatedAt?: string;
             version: string;
         };
+        ResourceVariable: {
+            key: string;
+            resourceId: string;
+            value: components["schemas"]["Value"];
+        };
         Selector: components["schemas"]["JsonSelector"] | components["schemas"]["CelSelector"];
         SensitiveValue: {
             valueHash: string;
@@ -3307,6 +3332,62 @@ export interface operations {
             };
         };
     };
+    getVariablesForResource: {
+        parameters: {
+            query?: {
+                /** @description Maximum number of items to return */
+                limit?: number;
+                /** @description Number of items to skip */
+                offset?: number;
+            };
+            header?: never;
+            path: {
+                /** @description ID of the workspace */
+                workspaceId: string;
+                /** @description Identifier of the resource */
+                identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The requested variables */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: components["schemas"]["ResourceVariable"][];
+                        /** @description Maximum number of items returned */
+                        limit: number;
+                        /** @description Number of items skipped */
+                        offset: number;
+                        /** @description Total number of items available */
+                        total: number;
+                    };
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
     listSystems: {
         parameters: {
             query?: {