Add tests and update dependencies

Author: vjdhama

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
-          node-version: 20
+          node-version: 23
           cache: npm
 
       - name: Install dependencies
@@ -36,7 +36,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
-          node-version: 20
+          node-version: 23
           cache: npm
 
       - name: Install dependencies

dist/index.js

@@ -1,29 +1,56 @@
 /**
- * Interface for Google Cloud Storage bucket upload options
+ * @fileoverview Type definitions and interfaces for the terraform-module-gcs-publisher.
+ * This module contains TypeScript interfaces that define the structure for module options,
+ * GCS bucket options, and other data structures used throughout the application.
+ *
+ * @author Infraspec
+ * @license MIT
+ */
+/**
+ * Interface for Google Cloud Storage bucket upload options.
+ * These options are used when uploading files to a GCS bucket.
  */
 export interface GCSBucketOptions {
+    /** Destination path within the bucket where the file will be stored */
     destination: string;
+    /** Metadata to associate with the uploaded file */
     metadata: {
+        /** MIME type of the file, typically 'application/zip' for module archives */
         contentType: string;
+        /** Cache control header, affects how the file is cached by browsers and CDNs */
         cacheControl: string;
+        /** Custom metadata fields that provide additional information about the file */
         metadata: {
+            /** SHA-256 hash of the file for integrity verification */
             sha256Hash: string;
+            /** Identifier for the uploader, typically the action name */
             uploadedBy: string;
+            /** ISO timestamp when the upload occurred */
             uploadTimestamp: string;
         };
     };
+    /** Validation method to use during upload (e.g., 'crc32c') */
     validation: string;
+    /** Whether to use resumable uploads, typically set to false for smaller files */
     resumable: boolean;
 }
 /**
- * Interface for module publishing options
+ * Interface for module publishing options.
+ * These options control how a Terraform module is published to GCS.
  */
 export interface ModuleOptions {
+    /** Name of the GCS bucket to upload to (must follow GCS naming rules) */
     bucketName: string;
+    /** Name of the Terraform module (used in path construction and file naming) */
     moduleName: string;
+    /** Semantic version of the module (e.g., '1.0.0') */
     moduleVersion: string;
+    /** Local filesystem path to the module directory */
     modulePath: string;
+    /** Google Cloud credentials JSON content for authentication */
     googleCredentialsJson: string;
+    /** Whether to delete older versions of the same module */
     deleteOldVersions: boolean;
+    /** Number of recent versions to retain when cleaning up old versions */
     keepVersions: number;
 }

dist/index.js.map

@@ -1,43 +1,84 @@
+/**
+ * @fileoverview Main entry point for the terraform-module-gcs-publisher GitHub Action.
+ * This module handles publishing Terraform modules to Google Cloud Storage with proper
+ * versioning, metadata, and cleanup of old versions. It implements the core functionality
+ * required by the action including input validation, file handling, GCS uploads, and
+ * version management.
+ *
+ * @author Infraspec
+ * @license MIT
+ */
 import { GCSService } from './services/gcs-service';
 import { ModuleOptions } from './interfaces';
 /**
- * Creates a zip archive of the module
+ * Creates a zip archive of the module for uploading to Google Cloud Storage.
+ * This function uses the system's zip command to create an archive while excluding
+ * git-related files and other unnecessary metadata files.
  *
- * @param sourcePath - Path to the module to be archived
- * @param outputPath - Path where the archive will be created
- * @returns The path to the created archive
+ * @param sourcePath - Path to the module directory to be archived
+ * @param outputPath - Path where the zip archive will be created
+ * @returns The path to the created zip archive
+ * @throws {Error} When the source path doesn't exist or isn't accessible
+ * @throws {Error} When the zip command fails to execute properly
+ * @throws {Error} When the output zip file cannot be created or verified
  */
 declare function createZipArchive(sourcePath: string, outputPath: string): Promise<string>;
 /**
- * Parses and validates all input parameters
+ * Parses and validates all input parameters from the GitHub Actions environment.
+ * This function extracts inputs using the @actions/core library and constructs
+ * a validated ModuleOptions object ready for use in the module publishing process.
  *
- * @returns Validated module options
+ * @returns Validated module options object with all required properties set
+ * @throws {Error} When required inputs are missing from the GitHub Actions context
+ * @throws {Error} When inputs fail validation via the validateInputs function
  */
 declare function getValidatedInputs(): ModuleOptions;
 /**
- * Validates the input parameters
+ * Validates the input parameters to the GitHub Action.
+ * This function performs comprehensive validation on all input parameters including
+ * format validation, existence checks, and semantic version validation.
  *
- * @param options - Module options to validate
+ * @param options - Module options object containing all parameters to validate
+ * @throws {Error} When the bucket name doesn't conform to GCS naming rules
+ * @throws {Error} When the module name contains invalid characters
+ * @throws {Error} When the module path doesn't exist on the filesystem
+ * @throws {Error} When the module version isn't a valid semantic version format
+ * @throws {Error} When the keepVersions parameter is not a positive integer
  */
 declare function validateInputs(options: ModuleOptions): void;
 /**
- * Creates a temporary file for Google credentials
+ * Creates a temporary file for Google credentials.
+ * This function validates the JSON format of the credentials and writes them to a
+ * temporary file that can be used by the Google Cloud Storage client library.
  *
- * @param credentialsJson - Google credentials JSON string
- * @returns Path to the created credentials file
+ * @param credentialsJson - Google credentials JSON string containing service account information
+ * @returns Path to the created temporary credentials file
+ * @throws {Error} When the credentials JSON is invalid or cannot be parsed
+ * @throws {Error} When the temporary file cannot be created due to file system errors
  */
 declare function createTempCredentialsFile(credentialsJson: string): string;
 /**
- * Processes the module upload and related operations
+ * Processes the module upload and related operations.
+ * This function calculates the file hash, performs the upload operation,
+ * and handles cleanup of old versions if requested in the options.
  *
- * @param options - Module options
- * @param gcsService - GCS service instance
- * @param zipFilePath - Path to the zip file to upload
- * @returns URL to the uploaded module
+ * @param options - Module options containing bucket name, module name, and version information
+ * @param gcsService - GCS service instance for interacting with Google Cloud Storage
+ * @param zipFilePath - Path to the local zip file to be uploaded
+ * @returns URL to the uploaded module in Google Cloud Storage (gs:// format)
+ * @throws {Error} When file hash calculation fails due to file system errors
+ * @throws {Error} When the upload to GCS fails due to authentication or network issues
+ * @throws {Error} When cleanup of old versions fails (if deleteOldVersions is true)
  */
 declare function processModuleUpload(options: ModuleOptions, gcsService: GCSService, zipFilePath: string): Promise<string>;
 /**
- * Main function that runs the action
+ * Main function that runs the GitHub Action for publishing Terraform modules to GCS.
+ * This is the entry point for the action that handles the entire process from reading
+ * inputs, validating parameters, creating the zip archive, and uploading to GCS.
+ *
+ * @throws {Error} When required inputs are missing or invalid
+ * @throws {Error} When zip creation fails due to file system issues
+ * @throws {Error} When GCS authentication or upload operations fail
  */
 declare function run(): Promise<void>;
 export { run, createZipArchive, getValidatedInputs, validateInputs, createTempCredentialsFile, processModuleUpload };