public async updateGreengrassGroupDefinitions()

in source/lambda/lib/greengrass-handler.ts [279:334]
43 lines of code
9 McCabe index (conditional complexity)

  public async updateGreengrassGroupDefinitions(input: GreengrassHandlerTypes.UpdateGreengrassDefinitionsRequest): Promise<{ [key: string]: string | undefined }> {
    try {
      logger.log(LoggingLevel.DEBUG, `Updating Greengrass group definitions: ${JSON.stringify(input, null, 2)}`);

      const newDefinitionVersionArns: { [key: string]: string | undefined } = {};
      const { greengrassGroupVersion, publisherLambdaFunctionAliasArn, collectorLambdaFunctionAliasArn } = input;
      const solutionGreengrassDefaultDefinitions = this.getSolutionGreengrassDefaultDefinitions({
        collectorLambdaFunctionAliasArn,
        publisherLambdaFunctionAliasArn
      });
      const definitions = Array.from(Object.values(GreengrassHandlerTypes.GreengrassDefinitions));

      for (let definition of definitions) {
        const latestDefinitionVersionArn = greengrassGroupVersion.Definition[`${definition}DefinitionVersionArn`];
        let greengrassDefinitionVersion: GreengrassDefinitionVersion = [];
        let definitionId: string | undefined;
        let definitionName: string | undefined;

        logger.log(LoggingLevel.DEBUG, `definition: ${definition}, latestDefinitionVersionArn: ${latestDefinitionVersionArn}`);

        if (latestDefinitionVersionArn) {
          const greengrassDefinition = await this.findGreengrassDefinition(latestDefinitionVersionArn, definition);
          definitionId = greengrassDefinition.Id;
          definitionName = greengrassDefinition.Name;

          logger.log(LoggingLevel.DEBUG, `definitionId: ${definitionId}, definitionName: ${definitionName}`);

          if (definitionId) {
            greengrassDefinitionVersion = await this.getGreengrassDefinitionVersion(greengrassDefinition.Id, greengrassDefinition.LatestVersion, definition);
          }
        }

        // Combines the current version Greengrass definitions and the default Greengrass definitions.
        let newDefinitions: any[] = solutionGreengrassDefaultDefinitions[definition];
        this.combineDefinitions(definition as GreengrassHandlerTypes.GreengrassDefinitions, newDefinitions, greengrassDefinitionVersion);

        // Only creates a definition when `m2c2-greengrass-${definition}Definition` does not exist.
        if (!definitionName || definitionName !== `m2c2-greengrass-${definition}Definition`) {
          const newDefinition = await this.createGreengrassDefinition(definition);
          definitionId = newDefinition.Id;
        }

        const newDefinitionVersion = await this.createGreengrassDefinitionVersion(definitionId, newDefinitions, definition);
        newDefinitionVersionArns[`${definition}DefinitionVersionArn`] = newDefinitionVersion.Arn;
      }

      return newDefinitionVersionArns;
    } catch (error) {
      logger.log(LoggingLevel.ERROR, '[updateGreengrassGroupDefinitions] Error: ', error);

      throw new LambdaError({
        message: error instanceof LambdaError ? error.message : 'Failed to update Greengrass group definitions',
        name: error instanceof LambdaError ? error.name : GreengrassHandlerTypes.ErrorTypes.UPDATE_GREENGRASS_GROUP_DEFINITION_ERROR
      });
    }
  }