fix(aws): applied scaffolder 2.0 zod migration

Signed-off-by: Florian JUDITH <florian.judith@alithya.com>

Author: fjudith

workspaces/aws/plugins/scaffolder-backend-module-aws-apps/src/actions/create-repo-access-token/create-repoAccesstoken.ts

@@ -7,46 +7,29 @@ import { parseRepoUrl } from '../../helpers/util';
 import { InputError } from '@backstage/errors';
 import { validate as validateArn } from '@aws-sdk/util-arn-parser';
 import { putSecret } from '../../helpers/action-context';
-import { Config } from '@backstage/config';
+import { RootConfigService } from '@backstage/backend-plugin-api';
 
 /** @public */
 export function createRepoAccessTokenAction(options: {
   integrations: ScmIntegrationRegistry;
-  envConfig: Config;
+  envConfig: RootConfigService;
 }) {
   const { integrations, envConfig } = options;
-  return createTemplateAction<{
-    repoUrl: string;
-    secretArn: string;
-    projectId: number;
-    region?: string;
-  }>({
+  return createTemplateAction({
     id: 'opa:createRepoAccessToken:gitlab',
     description:
       'Initializes a git repository of the content in the workspace, and publishes it to GitLab.',
     schema: {
       input: {
-        type: 'object',
-        required: ['repoUrl', 'secretArn', 'projectId'],
-        properties: {
-          repoUrl: {
-            title: 'Repository Location',
-            type: 'string',
-          },
-          projectId: {
-            title: 'Project Id',
-            type: 'number',
-          },
-          secretArn: {
-            title:
+        repoUrl: z => z.string().describe('Repository Location'),
+        projectId: z => z.number().describe('Project Id'),
+        secretArn: z =>
+          z
+            .string()
+            .describe(
               'Arn of the SecretsManager secret where the access token will be stored',
-            type: 'string',
-          },
-          region: {
-            title: 'AWS Region',
-            type: 'string',
-          },
-        },
+            ),
+        region: z => z.string().optional().describe('AWS Region'),
       },
     },
     async handler(ctx) {

workspaces/aws/plugins/scaffolder-backend-module-aws-apps/src/actions/create-s3-bucket/create-s3-bucket.ts

@@ -7,56 +7,34 @@ import { EnvironmentProvider } from '../../types';
 
 /** @public */
 export function createS3BucketAction() {
-  return createTemplateAction<{
-    bucketName: string;
-    envProviders: EnvironmentProvider[];
-    tags?: { Key: string; Value: string | number | boolean }[];
-  }>({
+  return createTemplateAction({
     id: 'opa:create-s3-bucket',
     description: 'Creates an S3 bucket',
     schema: {
       input: {
-        type: 'object',
-        required: ['bucketName', 'envProviders'],
-        properties: {
-          bucketName: {
-            title: 'Bucket Name',
-            description: 'The name of the S3 bucket to create',
-            type: 'string',
-          },
-          envProviders: {
-            title: 'AWS Environment Providers',
-            description:
+        bucketName: z =>
+          z.string().describe('The name of the S3 bucket to create'),
+        envProviders: z =>
+          z
+            .array(z.custom<EnvironmentProvider>())
+            .describe(
               'The AWS environment providers containing account and region info',
-            type: 'array',
-          },
-          tags: {
-            title: 'AWS Tags',
-            description:
+            ),
+        tags: z =>
+          z
+            .array(
+              z.object({
+                Key: z.string(),
+                Value: z.union([z.string(), z.number(), z.boolean()]),
+              }),
+            )
+            .optional()
+            .describe(
               'key/value pairs to apply as tags to any created AWS resources',
-            type: 'array',
-            minProperties: 1,
-            items: [
-              {
-                type: 'object',
-                properties: {
-                  Key: { type: 'string' },
-                  Value: { type: ['string', 'number', 'boolean'] },
-                },
-              },
-            ],
-          },
-        },
+            ),
       },
       output: {
-        type: 'object',
-        required: ['awsBucketName'],
-        properties: {
-          awsBucketName: {
-            title: 'S3 Bucket Name',
-            type: 'string',
-          },
-        },
+        awsBucketName: z => z.string().describe('S3 Bucket Name'),
       },
     },
     async handler() {

workspaces/aws/plugins/scaffolder-backend-module-aws-apps/src/actions/create-secret/create-secret.ts

@@ -3,66 +3,45 @@
 
 import { createTemplateAction } from '@backstage/plugin-scaffolder-node';
 import { createSecret } from '../../helpers/action-context';
-import { Config } from '@backstage/config';
+import { RootConfigService } from '@backstage/backend-plugin-api';
 
 /** @public */
-export function createSecretAction(options: { envConfig: Config }) {
+export function createSecretAction(options: { envConfig: RootConfigService }) {
   const { envConfig } = options;
-  return createTemplateAction<{
-    secretName: string;
-    description?: string;
-    region?: string;
-    tags?: { Key: string; Value: string | number | boolean }[];
-  }>({
+  return createTemplateAction({
     id: 'opa:create-secret',
     description: 'Creates secret in Secret Manager',
     schema: {
       input: {
-        type: 'object',
-        required: ['secretName'],
-        properties: {
-          secretName: {
-            title: 'Secret Name',
-            description: 'The name of the secret to create in SecretsManager',
-            type: 'string',
-          },
-          description: {
-            title: 'Description',
-            description: 'An optional description of the secret',
-            type: 'string',
-          },
-          region: {
-            title: 'AWS Region',
-            description:
-              'The AWS region where the new secret should be created',
-            type: 'string',
-          },
-          tags: {
-            title: 'AWS Tags',
-            description:
+        secretName: z =>
+          z
+            .string()
+            .describe('The name of the secret to create in SecretsManager'),
+        description: z =>
+          z
+            .string()
+            .optional()
+            .describe('An optional description of the secret'),
+        region: z =>
+          z
+            .string()
+            .optional()
+            .describe('The AWS region where the new secret should be created'),
+        tags: z =>
+          z
+            .array(
+              z.object({
+                Key: z.string(),
+                Value: z.union([z.string(), z.number(), z.boolean()]),
+              }),
+            )
+            .optional()
+            .describe(
               'key/value pairs to apply as tags to any created AWS resources',
-            type: 'array',
-            minProperties: 1,
-            items: [
-              {
-                type: 'object',
-                properties: {
-                  Key: { type: 'string' },
-                  Value: { type: ['string', 'number', 'boolean'] },
-                },
-              },
-            ],
-          },
-        },
+            ),
       },
       output: {
-        type: 'object',
-        properties: {
-          secretARN: {
-            title: 'SecretARN',
-            type: 'string',
-          },
-        },
+        secretARN: z => z.string().optional().describe('SecretARN'),
       },
     },
     async handler(ctx) {
@@ -83,7 +62,7 @@ export function createSecretAction(options: { envConfig: Config }) {
           tags,
           ctx.logger,
         );
-        ctx.output('awsSecretArn', ARN!);
+        ctx.output('secretARN', ARN!);
       } catch (e) {
         throw new Error(e instanceof Error ? e.message : JSON.stringify(e));
       }

workspaces/aws/plugins/scaffolder-backend-module-aws-apps/src/actions/get-component-info/get-component-info.ts

@@ -27,33 +27,17 @@ const examples = [
 
 /** @public */
 export function getComponentInfoAction() {
-  return createTemplateAction<{
-    componentName: string;
-  }>({
+  return createTemplateAction({
     id: ID,
     description: 'Sets useful component info for other actions to use',
     examples,
     schema: {
       input: {
-        type: 'object',
-        required: ['componentName'],
-        properties: {
-          componentName: {
-            title: 'Component Name',
-            description: 'The name of the component',
-            type: 'string',
-          },
-        },
+        componentName: z => z.string().describe('The name of the component'),
       },
       output: {
-        type: 'object',
-        required: ['kebabCaseComponentName'],
-        properties: {
-          kebabCaseComponentName: {
-            title: 'The component name, converted to kebab case',
-            type: 'string',
-          },
-        },
+        kebabCaseComponentName: z =>
+          z.string().describe('The component name, converted to kebab case'),
       },
     },
     async handler(ctx) {