rebase

Author: Goodsmileduck

.github/workflows/test-pr.yaml

@@ -17,10 +17,10 @@ jobs:
         node-version: 20
 
     - name: Install dependencies
-      run: yarn
+      run: npm ci
 
     - name: Rebuild the dist/ directory
-      run: yarn run package
+      run: npm run package
 
     - name: Compare the expected and actual dist/ directories
       run: |

dist/index.js

@@ -583658,25 +583658,54 @@ const stream_1 = __nccwpck_require__(2203);
 const client_s3_1 = __nccwpck_require__(53711);
 const nodejs_sdk_1 = __nccwpck_require__(6629);
 const archiver_1 = __importDefault(__nccwpck_require__(99392));
+/**
+ * Input validation utilities
+ */
+function validateNumericInput(value, name, min, max) {
+    if (!value || value.trim() === '') {
+        return 0; // Return default for empty values
+    }
+    const parsed = Number.parseFloat(value.trim());
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Invalid ${name}: "${value}" is not a valid number`);
+    }
+    if (min !== undefined && parsed < min) {
+        throw new Error(`Invalid ${name}: ${parsed} is below minimum value of ${min}`);
+    }
+    if (max !== undefined && parsed > max) {
+        throw new Error(`Invalid ${name}: ${parsed} exceeds maximum value of ${max}`);
+    }
+    return parsed;
+}
+function sanitizeInput(value) {
+    return (value === null || value === void 0 ? void 0 : value.trim()) || '';
+}
+function validateRequiredInput(value, name) {
+    const sanitized = sanitizeInput(value);
+    if (!sanitized) {
+        throw new Error(`Required input "${name}" is missing or empty`);
+    }
+    return sanitized;
+}
 ;
 async function run() {
     core.setCommandEcho(true);
     try {
         const inputs = {
-            functionId: core.getInput("function_id", { required: true }),
-            token: core.getInput("token", { required: true }),
-            accessKeyId: core.getInput("accessKeyId", { required: false }),
-            secretAccessKey: core.getInput("secretAccessKey", { required: false }),
-            runtime: core.getInput("runtime", { required: true }),
-            entrypoint: core.getInput("entrypoint", { required: true }),
-            memory: core.getInput("memory", { required: false }),
-            source: core.getInput("source", { required: false }),
-            sourceIgnore: core.getInput("exclude", { required: false }),
-            executionTimeout: core.getInput("execution_timeout", { required: false }),
-            environment: core.getInput("environment", { required: false }),
-            serviceAccount: core.getInput("service_account", { required: false }),
-            bucket: core.getInput("bucket", { required: false }),
-            description: core.getInput("description", { required: false }),
+            functionId: validateRequiredInput(core.getInput("function_id", { required: true }), "function_id"),
+            token: validateRequiredInput(core.getInput("token", { required: true }), "token"),
+            accessKeyId: sanitizeInput(core.getInput("accessKeyId", { required: false })),
+            secretAccessKey: sanitizeInput(core.getInput("secretAccessKey", { required: false })),
+            runtime: validateRequiredInput(core.getInput("runtime", { required: true }), "runtime"),
+            entrypoint: validateRequiredInput(core.getInput("entrypoint", { required: true }), "entrypoint"),
+            memory: sanitizeInput(core.getInput("memory", { required: false })) || "128",
+            source: sanitizeInput(core.getInput("source", { required: false })) || ".",
+            sourceIgnore: sanitizeInput(core.getInput("exclude", { required: false })),
+            executionTimeout: sanitizeInput(core.getInput("execution_timeout", { required: false })) || "5",
+            environment: sanitizeInput(core.getInput("environment", { required: false })),
+            serviceAccount: sanitizeInput(core.getInput("service_account", { required: false })),
+            bucket: sanitizeInput(core.getInput("bucket", { required: false })),
+            description: sanitizeInput(core.getInput("description", { required: false })),
         };
         core.info("Function inputs set");
         const fileContents = await zipDirectory(inputs);
@@ -583697,8 +583726,7 @@ async function tryStoreObjectInBucket(inputs, fileContents) {
     if (!inputs.bucket)
         return;
     if (!inputs.accessKeyId || !inputs.secretAccessKey) {
-        core.setFailed("Missing ACCESS_KEY_ID or SECRET_ACCESS_KEY");
-        return;
+        throw new Error("Missing ACCESS_KEY_ID or SECRET_ACCESS_KEY when bucket is specified");
     }
     // setting object name
     const bucketObjectName = constructBucketObjectName(inputs);
@@ -583727,8 +583755,8 @@ function handleOperationError(operation) {
     if (operation.error) {
         const details = (_a = operation.error) === null || _a === void 0 ? void 0 : _a.details;
         if (details)
-            throw Error(`${operation.error.code}: ${operation.error.message} (${details.join(", ")})`);
-        throw Error(`${operation.error.code}: ${operation.error.message}`);
+            throw new Error(`${operation.error.code}: ${operation.error.message} (${details.join(", ")})`);
+        throw new Error(`${operation.error.code}: ${operation.error.message}`);
     }
 }
 async function getFunctionById(session, inputs) {
@@ -583742,7 +583770,7 @@ async function getFunctionById(session, inputs) {
             core.info(`Function found: "${foundFunction.id} (${foundFunction.name})"`);
             return foundFunction;
         }
-        throw Error("Failed to find Function by id");
+        throw new Error(`Failed to find function with ID: ${inputs.functionId}`);
     }
     finally {
         core.endGroup();
@@ -583754,17 +583782,17 @@ async function createFunctionVersion(session, targetFunction, fileContents, inpu
     core.startGroup("Create function version");
     try {
         core.info(`Function ${inputs.functionId}`);
-        //convert variables
-        const memory = Number.parseFloat(inputs.memory);
-        core.info(`Parsed memory: "${memory}"`);
-        const executionTimeout = Number.parseFloat(inputs.executionTimeout);
-        core.info(`Parsed timeout: "${executionTimeout}"`);
+        // Convert and validate variables
+        const memory = validateNumericInput(inputs.memory, "memory", 128, 4096); // 128MB to 4GB
+        core.info(`Parsed memory: "${memory}MB"`);
+        const executionTimeout = validateNumericInput(inputs.executionTimeout, "execution_timeout", 1, 900); // 1s to 15min
+        core.info(`Parsed timeout: "${executionTimeout}s"`);
         const request = CreateFunctionVersionRequest.fromPartial({
             functionId: targetFunction.id,
             runtime: inputs.runtime,
             entrypoint: inputs.entrypoint,
             resources: {
-                memory: memory ? memory * 1024 * 1024 : undefined,
+                memory: memory > 0 ? memory * 1024 * 1024 : 128 * 1024 * 1024, // Default to 128MB
             },
             serviceAccountId: inputs.serviceAccount,
             description: inputs.description,
@@ -583800,8 +583828,7 @@ function constructBucketObjectName(inputs) {
     const { GITHUB_SHA } = process.env;
     // check SHA present
     if (!GITHUB_SHA) {
-        core.setFailed("Missing GITHUB_SHA");
-        return "";
+        throw new Error("Missing GITHUB_SHA environment variable");
     }
     return `${inputs.functionId}/${GITHUB_SHA}.zip`;
 }
@@ -583827,7 +583854,7 @@ async function zipDirectory(inputs) {
         bufferStream.end();
         const buffer = await streamToBuffer(bufferStream);
         if (!buffer)
-            throw Error("Failed to initialize Buffer");
+            throw new Error("Failed to initialize buffer from stream");
         core.info("Buffer object created");
         return buffer;
     }
@@ -583836,14 +583863,19 @@ async function zipDirectory(inputs) {
     }
 }
 function parseIgnoreGlobPatterns(ignoreString) {
+    if (!ignoreString || ignoreString.trim() === '') {
+        return [];
+    }
     const result = [];
     const patterns = ignoreString.split(",");
     patterns.forEach(pattern => {
-        // only not empty patterns
-        if ((pattern === null || pattern === void 0 ? void 0 : pattern.length) > 0)
-            result.push(pattern);
+        const trimmed = pattern.trim();
+        // only non-empty patterns after trimming
+        if (trimmed.length > 0) {
+            result.push(trimmed);
+        }
     });
-    core.info(`Source ignore pattern: "${JSON.stringify(result)}"`);
+    core.info(`Source ignore patterns: "${JSON.stringify(result)}"`);
     return result;
 }
 function streamToBuffer(stream) {
@@ -583855,16 +583887,30 @@ function streamToBuffer(stream) {
     });
 }
 function parseEnvironmentVariables(env) {
-    core.info(`Environment string: "${env}"`);
+    if (!env || env.trim() === '') {
+        return {};
+    }
+    core.info(`Environment string provided: ${env.length} characters`);
     const envObject = {};
     const kvs = env.split(",");
-    kvs.forEach(kv => {
-        const eqIndex = kv.indexOf("=");
-        const key = kv.substring(0, eqIndex);
-        const value = kv.substring(eqIndex + 1);
+    kvs.forEach((kv, index) => {
+        const trimmed = kv.trim();
+        if (!trimmed)
+            return; // Skip empty entries
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1) {
+            core.warning(`Skipping invalid environment variable at index ${index}: "${trimmed}" (missing =)`);
+            return;
+        }
+        const key = trimmed.substring(0, eqIndex).trim();
+        const value = trimmed.substring(eqIndex + 1).trim();
+        if (!key) {
+            core.warning(`Skipping environment variable with empty key at index ${index}`);
+            return;
+        }
         envObject[key] = value;
     });
-    core.info(`EnvObject: "${JSON.stringify(envObject)}"`);
+    core.info(`Parsed ${Object.keys(envObject).length} environment variables`);
     return envObject;
 }
 run();