bundling: getNodejsBundlingOptions()

in lib/cdk-stack.ts [286:452]
135 lines of code
3 McCabe index (conditional complexity)

          bundling: getNodejsBundlingOptions(playPodcastId),
          ...commonProps,
        }),
      };
      break;

    default:
      throw new Error(`unknown workshop language, ${props.workshopLanguage}`);
  }

  //------------------------------
  // List Podcast
  //------------------------------
  handlers.listPodcastsFn.addToRolePolicy(
    iamUtils.makePolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: ['dynamodb:Scan'],
      resources: [props.podcastEpisodeTable.tableArn],
    })
  );

  //------------------------------
  // Add Podcast
  //------------------------------
  handlers.addPodcastFn.addToRolePolicy(
    iamUtils.makePolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: ['states:StartExecution'],
      resources: [props.transcribeStateMachine.stateMachineArn],
    })
  );
  handlers.addPodcastFn.addToRolePolicy(
    iamUtils.makePolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: [
        'dynamodb:BatchGetItem',
        'dynamodb:BatchWriteItem',
        'dynamodb:UpdateItem',
      ],
      resources: [props.podcastEpisodeTable.tableArn],
    })
  );

  //------------------------------
  // Get Podcasts
  //------------------------------
  if (handlers.getPodcastFn.role) {
    props.podcastEpisodeTable.grantReadData(handlers.getPodcastFn.role);
  }

  //------------------------------
  // Play Podcast
  //------------------------------
  handlers.playPodcastFn.addToRolePolicy(
    iamUtils.makePolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: ['dynamodb:GetItem'],
      resources: [props.podcastEpisodeTable.tableArn],
    })
  );
  handlers.playPodcastFn.addToRolePolicy(
    iamUtils.makePolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: [
        's3:AbortMultipartUpload',
        's3:GetBucketLocation',
        's3:GetObject',
        's3:ListBucket',
        's3:ListBucketMultipartUploads',
        's3:PutObject',
      ],
      resources: [
        props.podcastBucket.bucketArn,
        props.podcastBucket.bucketArn + '/*',
      ],
    })
  );

  return handlers;
}

interface transcribeStatemachineHandlers {
  updateEpisodeStatus: lambda.IFunction;
  uploadPodcast: lambda.IFunction;
  startTranscription: lambda.IFunction;
  checkTranscription: lambda.IFunction;
  processTranscription: lambda.IFunction;
}

interface makeTranscribeStatemachineLambdasProps {
  podcastBucket: s3.IBucket;
  podcastEpisodeTable: ddb.ITable;
  transcribeAccessRole: iam.IRole;

  workshopLanguage: WorkshopLanguage;
}

function makeTranscribeStatemachineLambdas(
  scope: cdk.Construct,
  id: string,
  props: makeTranscribeStatemachineLambdasProps
): transcribeStatemachineHandlers {
  const uploadPodcastId = id + 'UploadPodcast';
  const startTranscriptionId = id + 'StartTranscription';
  const checkTranscriptionId = id + 'CheckTranscription';
  const processTranscriptionId = id + 'CleanupTranscription';

  const commonProps = {
    environment: {
      [ENV_KEY_PODCAST_EPISODE_TABLE_NAME]: props.podcastEpisodeTable.tableName,
      [ENV_KEY_PODCAST_DATA_BUCKET_NAME]: props.podcastBucket.bucketName,
      [ENV_KEY_TRANSCRIBE_ACCESS_ROLE_ARN]: props.transcribeAccessRole.roleArn,
      ...commonStaticLambdaEnvs,
    },
    memorySize: 1024,
    timeout: cdk.Duration.seconds(60),
  };

  // Lambda handler implementations common across all languages
  const updateEpisodeStatus = new lambda.Function(
    scope,
    id + 'UpdateEpisodeStatus',
    {
      runtime: lambda.Runtime.GO_1_X,
      handler: 'main',
      code: lambda.Code.fromAsset('lambda/go/update-episode-status'),
      ...commonProps,
    }
  );

  const startTranscription = new lambda.Function(scope, startTranscriptionId, {
    runtime: lambda.Runtime.GO_1_X,
    handler: 'main',
    code: lambda.Code.fromAsset('lambda/go/start-transcription'),
    ...commonProps,
  });

  const checkTranscription = new lambda.Function(scope, checkTranscriptionId, {
    runtime: lambda.Runtime.GO_1_X,
    handler: 'main',
    code: lambda.Code.fromAsset('lambda/go/check-transcription'),
    ...commonProps,
  });

  const processTranscription = new lambda.Function(
    scope,
    processTranscriptionId,
    {
      runtime: lambda.Runtime.GO_1_X,
      handler: 'main',
      code: lambda.Code.fromAsset('lambda/go/process-transcription'),
      ...commonProps,
    }
  );

  let handlers: transcribeStatemachineHandlers;
  switch (props.workshopLanguage) {
    case WorkshopLanguage.Go:
      handlers = {
        // Common handlers
        updateEpisodeStatus: updateEpisodeStatus,
        startTranscription: startTranscription,
        checkTranscription: checkTranscription,
        processTranscription: processTranscription,

        // language specific handlers
        uploadPodcast: new lambda.Function(scope, uploadPodcastId, {