chore(sdk): enable stricter type-checked eslint rules

Author: anthonyting

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

@@ -0,0 +1,115 @@
+// @ts-check
+
+import filenameConvention from "eslint-plugin-filename-convention";
+import eslintConfigPrettier from "eslint-config-prettier/flat";
+import tsdoc from "eslint-plugin-tsdoc";
+import { defineConfig } from "eslint/config";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import js from "@eslint/js";
+import { fileURLToPath } from "node:url";
+import { includeIgnoreFile } from "@eslint/compat";
+
+const gitIgnorePath = fileURLToPath(new URL(".gitignore", import.meta.url));
+
+export default defineConfig([
+  includeIgnoreFile(gitIgnorePath, "Imported .gitignore patterns"),
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+    plugins: { js },
+    extends: ["js/recommended"],
+  },
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+    languageOptions: { globals: globals.node },
+  },
+  tseslint.configs.strictTypeChecked,
+  tseslint.configs.stylisticTypeChecked,
+  {
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parserOptions: {
+        projectService: {
+          allowDefaultProject: ["*.mjs"],
+        },
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    plugins: {
+      "filename-convention": filenameConvention,
+      tsdoc: tsdoc,
+    },
+    rules: {
+      // Rules that are temporarily set to warning, but should be switched to errors
+      "@typescript-eslint/restrict-template-expressions": [
+        "warn",
+        {
+          allowNumber: true,
+          allowBoolean: true,
+        },
+      ],
+      "@typescript-eslint/no-unsafe-assignment": "warn",
+      "@typescript-eslint/no-unsafe-argument": "warn",
+      "@typescript-eslint/no-non-null-assertion": "warn",
+      "@typescript-eslint/no-floating-promises": "warn",
+      "no-empty": "warn",
+      "@typescript-eslint/no-unsafe-return": "warn",
+      "@typescript-eslint/prefer-nullish-coalescing": "warn",
+      "no-async-promise-executor": "warn",
+      "@typescript-eslint/no-empty-function": "warn",
+      "@typescript-eslint/no-misused-promises": "warn",
+      "@typescript-eslint/only-throw-error": "warn",
+      "@typescript-eslint/use-unknown-in-catch-callback-variable": "warn",
+      "@typescript-eslint/no-unsafe-member-access": "warn",
+
+      // Modified rules
+      "@typescript-eslint/no-confusing-void-expression": [
+        "error",
+        {
+          ignoreArrowShorthand: true,
+        },
+      ],
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          caughtErrorsIgnorePattern: "^_",
+        },
+      ],
+
+      // Additional custom rules
+      "no-console": "error",
+      "no-debugger": "error",
+      "no-duplicate-imports": "error",
+      "filename-convention/kebab-case": "error",
+      "tsdoc/syntax": "warn",
+
+      // Disabled rules
+
+      // Async functions without await allow throwing async promises still
+      "@typescript-eslint/require-await": "off",
+      // Validation of parameters will create "unnecessary" conditions
+      "@typescript-eslint/no-unnecessary-condition": "off",
+    },
+  },
+  {
+    files: ["src/**/*.test.ts"],
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-empty-function": "off",
+      "@typescript-eslint/no-unsafe-return": "off",
+      "@typescript-eslint/no-unsafe-member-access": "off",
+      "@typescript-eslint/unbound-method": "off",
+      "@typescript-eslint/no-unsafe-call": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-argument": "off",
+      "@typescript-eslint/restrict-plus-operands": "off",
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/no-floating-promises": "off",
+      "@typescript-eslint/only-throw-error": "off",
+    },
+  },
+  eslintConfigPrettier,
+]);

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

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * @fileoverview ESLint plugin to enforce kebab-case for file names
  */
@@ -77,7 +79,8 @@ function findProjectRoot(startDir) {
   return null;
 }
 
-module.exports = {
+/** @type {import('eslint').ESLint.Plugin} */
+const plugin = {
   rules: {
     "kebab-case": {
       meta: {
@@ -87,15 +90,15 @@ module.exports = {
           category: "Stylistic Issues",
           recommended: true,
         },
-        fixable: null,
+        fixable: undefined,
         schema: [],
       },
       create: function (context) {
         // Use default ignore patterns (ESLint v9+ doesn't support CLIEngine)
         let ignorePatterns = defaultIgnorePatterns;
 
         // Function to check if a path should be ignored
-        const shouldIgnorePath = (filePath) => {
+        const shouldIgnorePath = (/** @type {string} */ filePath) => {
           // Convert to posix path for consistent pattern matching
           const posixPath = filePath.split(path.sep).join("/");
 
@@ -178,3 +181,5 @@ module.exports = {
     },
   },
 };
+
+module.exports = plugin;

packages/aws-durable-execution-sdk-js/scripts/eslint-plugin-filename-convention/index.js

@@ -51,9 +51,9 @@ import { validateContextUsage } from "../../utils/context-tracker/context-tracke
 
 export class DurableContextImpl implements DurableContext {
   private _stepPrefix?: string;
-  private _stepCounter: number = 0;
+  private _stepCounter = 0;
   private contextLogger: Logger | null;
-  private modeAwareLoggingEnabled: boolean = true;
+  private modeAwareLoggingEnabled = true;
   private runningOperations = new Set<string>();
   private operationsEmitter = new EventEmitter();
   private checkpoint: ReturnType<typeof createCheckpoint>;
@@ -361,7 +361,7 @@ export class DurableContextImpl implements DurableContext {
   }
 
   waitForCallback<T>(
-    nameOrSubmitter?: string | undefined | WaitForCallbackSubmitterFunc,
+    nameOrSubmitter?: string | WaitForCallbackSubmitterFunc,
     submitterOrConfig?: WaitForCallbackSubmitterFunc | WaitForCallbackConfig<T>,
     maybeConfig?: WaitForCallbackConfig<T>,
   ): DurablePromise<T> {
@@ -376,7 +376,7 @@ export class DurableContextImpl implements DurableContext {
         this.runInChildContext.bind(this),
       );
       return waitForCallbackHandler(
-        nameOrSubmitter!,
+        nameOrSubmitter,
         submitterOrConfig,
         maybeConfig,
       );
@@ -413,7 +413,7 @@ export class DurableContextImpl implements DurableContext {
         ? waitForConditionHandler(
             nameOrCheckFunc,
             checkFuncOrConfig as WaitForConditionCheckFunc<T>,
-            maybeConfig!,
+            maybeConfig,
           )
         : waitForConditionHandler(
             nameOrCheckFunc,

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

@@ -56,16 +56,15 @@ export const initializeExecutionContext = async (
 
   log("📝", "Operations:", operationsArray);
 
-  const stepData: Record<string, Operation> = operationsArray.reduce(
-    (acc, operation: Operation) => {
-      if (operation.Id) {
-        // The stepData received from backend has Id and ParentId as hash, so no need to hash it again
-        acc[operation.Id] = operation;
-      }
-      return acc;
-    },
-    {} as Record<string, Operation>,
-  );
+  const stepData: Record<string, Operation> = operationsArray.reduce<
+    Record<string, Operation>
+  >((acc, operation: Operation) => {
+    if (operation.Id) {
+      // The stepData received from backend has Id and ParentId as hash, so no need to hash it again
+      acc[operation.Id] = operation;
+    }
+    return acc;
+  }, {});
 
   log("📝", "Loaded step data:", stepData);
 

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

@@ -11,26 +11,14 @@ import { TerminationReason } from "../../termination-manager/types";
 // Create concrete implementations for testing
 class TestUnrecoverableError extends UnrecoverableError {
   readonly terminationReason = TerminationReason.CUSTOM;
-
-  constructor(message: string, originalError?: Error) {
-    super(message, originalError);
-  }
 }
 
 class TestExecutionError extends UnrecoverableExecutionError {
   readonly terminationReason = TerminationReason.CUSTOM;
-
-  constructor(message: string, originalError?: Error) {
-    super(message, originalError);
-  }
 }
 
 class TestInvocationError extends UnrecoverableInvocationError {
   readonly terminationReason = TerminationReason.CUSTOM;
-
-  constructor(message: string, originalError?: Error) {
-    super(message, originalError);
-  }
 }
 
 describe("UnrecoverableError", () => {

packages/aws-durable-execution-sdk-js/src/errors/unrecoverable-error/unrecoverable-error.test.ts

@@ -31,7 +31,7 @@ export const createCallback = (
   parentId?: string,
 ) => {
   return <T>(
-    nameOrConfig?: string | undefined | CreateCallbackConfig<T>,
+    nameOrConfig?: string | CreateCallbackConfig<T>,
     maybeConfig?: CreateCallbackConfig<T>,
   ): DurablePromise<CreateCallbackResult<T>> => {
     let name: string | undefined;

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

@@ -8,28 +8,28 @@ import { Serdes, SerdesContext } from "../../utils/serdes/serdes";
 
 export class BatchResultImpl<R> implements BatchResult<R> {
   constructor(
-    public readonly all: Array<BatchItem<R>>,
+    public readonly all: BatchItem<R>[],
     public readonly completionReason:
       | "ALL_COMPLETED"
       | "MIN_SUCCESSFUL_REACHED"
       | "FAILURE_TOLERANCE_EXCEEDED",
   ) {}
 
-  succeeded(): Array<BatchItem<R> & { result: R }> {
+  succeeded(): (BatchItem<R> & { result: R })[] {
     return this.all.filter(
       (item): item is BatchItem<R> & { result: R } =>
         item.status === BatchItemStatus.SUCCEEDED && item.result !== undefined,
     );
   }
 
-  failed(): Array<BatchItem<R> & { error: ChildContextError }> {
+  failed(): (BatchItem<R> & { error: ChildContextError })[] {
     return this.all.filter(
       (item): item is BatchItem<R> & { error: ChildContextError } =>
         item.status === BatchItemStatus.FAILED && item.error !== undefined,
     );
   }
 
-  started(): Array<BatchItem<R> & { status: BatchItemStatus.STARTED }> {
+  started(): (BatchItem<R> & { status: BatchItemStatus.STARTED })[] {
     return this.all.filter(
       (item): item is BatchItem<R> & { status: BatchItemStatus.STARTED } =>
         item.status === BatchItemStatus.STARTED,
@@ -53,11 +53,11 @@ export class BatchResultImpl<R> implements BatchResult<R> {
     }
   }
 
-  getResults(): Array<R> {
+  getResults(): R[] {
     return this.succeeded().map((item) => item.result);
   }
 
-  getErrors(): Array<ChildContextError> {
+  getErrors(): ChildContextError[] {
     return this.failed().map((item) => item.error);
   }
 

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

@@ -742,7 +742,7 @@ describe("ConcurrencyController", () => {
       const executor = jest.fn();
 
       // Resolve in reverse order
-      let resolvers: Array<(value: any) => void> = [];
+      const resolvers: ((value: any) => void)[] = [];
       mockParentContext.runInChildContext.mockImplementation(() => {
         return new Promise((resolve) => {
           resolvers.push(resolve);