refactor(sdk): fix ESLint warnings and improve code quality (#85)

- Configure ESLint to ignore unused parameters prefixed with underscore
- Add test-specific ESLint config to disable explicit-any warnings for
unit test files
- Prefix unused parameters with underscore across handlers and utilities
- Add proper TypeScript return type annotations
- Remove unused imports and variables
- Update TSDoc comments to use proper syntax
- Clean up console.log statements and test artifacts

*Issue #, if available:*

*Description of changes:*


By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice.

Co-authored-by: Pooya Paridel <parpooya@amazon.com>

Author: ParidelPooya

packages/aws-durable-execution-sdk-js/bundle-size-history.json

@@ -1,9 +1,4 @@
 [
-  {
-    "timestamp": "2025-06-27T16:38:03.394Z",
-    "size": 888765,
-    "gitCommit": "415861a578f98b671fdcdd598e56d7a001a95294"
-  },
   {
     "timestamp": "2025-06-27T16:46:43.149Z",
     "size": 888765,
@@ -248,5 +243,10 @@
     "timestamp": "2025-09-27T19:52:39.277Z",
     "size": 361660,
     "gitCommit": "fed4cf7151607892268067a15ca3430c2f6abbbc"
+  },
+  {
+    "timestamp": "2025-09-29T03:15:18.425Z",
+    "size": 361568,
+    "gitCommit": "71b458e8159dfc4242c4e8c65820a6c21554e16c"
   }
-]
+]

packages/aws-durable-execution-sdk-js/eslint.config.js

@@ -17,20 +17,44 @@ module.exports = [
     plugins: {
       "@typescript-eslint": typescriptEslint,
       "filename-convention": filenameConvention,
-      "tsdoc": tsdoc,
+      tsdoc: tsdoc,
     },
     rules: {
       ...typescriptEslint.configs.recommended.rules,
       "@typescript-eslint/no-explicit-any": "warn",
       "@typescript-eslint/explicit-function-return-type": "warn",
-      "@typescript-eslint/no-unused-vars": "warn",
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          caughtErrorsIgnorePattern: "^_",
+        },
+      ],
       "no-console": "warn",
       "no-debugger": "warn",
       "no-duplicate-imports": "error",
       "filename-convention/kebab-case": "error",
       "tsdoc/syntax": "warn",
     },
   },
+  {
+    files: ["src/**/*.test.ts"],
+    languageOptions: {
+      parser: tsParser,
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parserOptions: {
+        tsconfigRootDir: __dirname,
+      },
+    },
+    plugins: {
+      "@typescript-eslint": typescriptEslint,
+    },
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+    },
+  },
   {
     ignores: ["dist/**/*", "node_modules/**/*"],
   },

packages/aws-durable-execution-sdk-js/src/context/durable-context/durable-context.test.ts

@@ -160,8 +160,8 @@ describe("Durable Context", () => {
     const input = { test: "data" };
     const config = {
       payloadSerdes: {
-        serialize: async () => "test",
-        deserialize: async () => ({}),
+        serialize: async (): Promise<string> => "test",
+        deserialize: async (): Promise<object> => ({}),
       },
     };
 

packages/aws-durable-execution-sdk-js/src/context/execution-context/execution-context.test.ts

@@ -438,7 +438,7 @@ describe("initializeExecutionContext", () => {
     };
 
     // Execute
-    const result = await initializeExecutionContext(eventWithLocalRunner);
+    await initializeExecutionContext(eventWithLocalRunner);
 
     // Verify
     expect(ExecutionStateFactory.createExecutionState).toHaveBeenCalledWith(
@@ -509,7 +509,7 @@ describe("initializeExecutionContext", () => {
 
     // Test that it calls the utility function correctly
     // Since the step is stored with ID "step1", the getStepData should find it
-    const stepData = result.executionContext.getStepData(stepId);
+    result.executionContext.getStepData(stepId);
     // The actual behavior depends on the hash function, but we can verify the method exists and returns something
     expect(result.executionContext.getStepData).toBeDefined();
   });

packages/aws-durable-execution-sdk-js/src/context/execution-context/execution-context.ts

@@ -78,7 +78,7 @@ export const initializeExecutionContext = async (
       isLocalMode,
       isVerbose,
       durableExecutionArn,
-      getStepData(stepId: string) {
+      getStepData(stepId: string): Operation | undefined {
         return getStepDataUtil(stepData, stepId);
       },
     },

packages/aws-durable-execution-sdk-js/src/errors/step-errors/step-errors.ts

@@ -3,7 +3,7 @@
  * before completion.
  */
 export class StepInterruptedError extends Error {
-  constructor(stepId: string, stepName?: string) {
+  constructor(_stepId: string, _stepName?: string) {
     super(
       `The step execution process was initiated but failed to reach completion due to an interruption.`,
     );

packages/aws-durable-execution-sdk-js/src/handlers/callback-handler/promise-interface.test.ts

@@ -14,7 +14,7 @@ describe("Callback Handler Promise Interface", () => {
 
   beforeEach(() => {
     stepIdCounter = 0;
-    createStepId = () => `step-${++stepIdCounter}`;
+    createStepId = (): string => `step-${++stepIdCounter}`;
     mockHasRunningOperations = jest.fn().mockReturnValue(false);
 
     mockContext = createMockExecutionContext();
@@ -158,10 +158,10 @@ describe("Callback Handler Promise Interface", () => {
       const [promise] = await callbackHandler<string>("test-callback");
 
       // This should not throw a compilation error and should trigger termination
-      const asyncFunction = async () => {
+      const asyncFunction = async (): Promise<void> => {
         try {
           await promise; // This should trigger termination
-        } catch (error) {
+        } catch (_error) {
           // Handle error
         }
       };

packages/aws-durable-execution-sdk-js/src/handlers/concurrent-execution-handler/concurrent-execution-handler.ts

@@ -122,7 +122,7 @@ export class ConcurrencyController {
         return "FAILURE_TOLERANCE_EXCEEDED";
       };
 
-      const tryStartNext = () => {
+      const tryStartNext = (): void => {
         while (
           activeCount < maxConcurrency &&
           currentIndex < items.length &&
@@ -192,7 +192,7 @@ export class ConcurrencyController {
         }
       };
 
-      const onComplete = () => {
+      const onComplete = (): void => {
         activeCount--;
         completedCount++;
 
@@ -282,7 +282,7 @@ export const createConcurrentExecutionHandler = (
       );
     }
 
-    const executeOperation = async (executionContext: DurableContext) => {
+    const executeOperation = async (executionContext: DurableContext): Promise<BatchResult<TResult>> => {
       const concurrencyController = new ConcurrencyController(
         context.isVerbose,
         "concurrent-execution",

packages/aws-durable-execution-sdk-js/src/handlers/invoke-handler/invoke-handler.test.ts

@@ -357,8 +357,8 @@ describe("InvokeHandler", () => {
 
       const config = {
         payloadSerdes: {
-          serialize: async () => "custom",
-          deserialize: async () => ({}),
+          serialize: async (): Promise<string> => "custom",
+          deserialize: async (): Promise<object> => ({}),
         },
         timeoutSeconds: 30,
       };

packages/aws-durable-execution-sdk-js/src/handlers/invoke-handler/invoke-handler.ts

@@ -19,8 +19,16 @@ export const createInvokeHandler = (
   context: ExecutionContext,
   checkpoint: ReturnType<typeof createCheckpoint>,
   createStepId: () => string,
-  hasRunningOperations: () => boolean,
-) => {
+  _hasRunningOperations: () => boolean,
+): {
+  <I, O>(funcId: string, input: I, config?: InvokeConfig<I, O>): Promise<O>;
+  <I, O>(
+    name: string,
+    funcId: string,
+    input: I,
+    config?: InvokeConfig<I, O>,
+  ): Promise<O>;
+} => {
   function invokeHandler<I, O>(
     funcId: string,
     input: I,