Merge branch 'main' of https://github.com/microsoft/durabletask-js into wangbill/entities

Author: YunchuWang

.eslintignore

@@ -0,0 +1,65 @@
+# Summary
+
+## What changed?
+-
+
+## Why is this change needed?
+-
+
+## Issues / work items
+- Resolves #
+- Related #
+
+---
+
+# Project checklist
+- [ ] Release notes are not required for the next release
+  - [ ] Otherwise: Notes added to `CHANGELOG.md`
+- [ ] Backport is not required
+  - [ ] Otherwise: Backport tracked by issue/PR #issue_or_pr
+- [ ] All required tests have been added/updated (unit tests, E2E tests)
+- [ ] Breaking change?
+  - [ ] If yes:
+    - Impact:
+    - Migration guidance:
+
+---
+
+# AI-assisted code disclosure (required)
+
+## Was an AI tool used? (select one)
+- [ ] No
+- [ ] Yes, AI helped write parts of this PR (e.g., GitHub Copilot)
+- [ ] Yes, an AI agent generated most of this PR
+
+If AI was used:
+- Tool(s):
+- AI-assisted areas/files:
+- What you changed after AI output:
+
+AI verification (required if AI was used):
+- [ ] I understand the code and can explain it
+- [ ] I verified referenced APIs/types exist and are correct
+- [ ] I reviewed edge cases/failure paths (timeouts, retries, cancellation, exceptions)
+- [ ] I reviewed concurrency/async behavior
+- [ ] I checked for unintended breaking or behavior changes
+
+---
+
+# Testing
+
+## Automated tests
+- Result: Passed / Failed (link logs if failed)
+
+## Manual validation (only if runtime/behavior changed)
+- Environment (OS, Node.js version, components):
+- Steps + observed results:
+  1.
+  2.
+  3.
+- Evidence (optional):
+
+---
+
+# Notes for reviewers
+- N/A

.eslintrc.json

@@ -5,7 +5,7 @@
 !.vscode/launch.json
 !.vscode/extensions.json
 *.code-workspace
-
+.DS_Store
 ### DotnetCore ###
 # .NET Core build folders
 bin/

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged

.gitignore

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+import globals from "globals";
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: "module",
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+      },
+    },
+    rules: {
+      "@typescript-eslint/ban-ts-comment": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-inferrable-types": "off",
+      "@typescript-eslint/no-empty-function": "off",
+      "@typescript-eslint/no-require-imports": "off",
+      "no-constant-condition": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          varsIgnorePattern: "^_",
+          argsIgnorePattern: "^_",
+        },
+      ],
+    },
+  },
+  {
+    ignores: [
+      "**/dist/**",
+      "**/node_modules/**",
+      "**/src/version.ts",
+      "**/jest.config.js",
+      "**/src/proto/**",
+    ],
+  }
+);

.husky/pre-commit

@@ -14,6 +14,10 @@ import { DefaultAzureCredential } from "@azure/identity";
 import {
   createAzureManagedClient,
   createAzureManagedWorkerBuilder,
+  // Logger types are re-exported for convenience
+  // ConsoleLogger is used by default
+  // Use createAzureLogger to integrate with @azure/logger
+  createAzureLogger,
 } from "../extensions/durabletask-js-azuremanaged/build";
 import { ActivityContext } from "../src/task/context/activity-context";
 import { OrchestrationContext } from "../src/task/context/orchestration-context";
@@ -23,6 +27,10 @@ import { Task } from "../src/task/task";
 
 // Wrap the entire code in an immediately-invoked async function
 (async () => {
+  // Create a logger for this example
+  // This uses Azure SDK's logging infrastructure - set AZURE_LOG_LEVEL=verbose to see all logs
+  const logger = createAzureLogger("example");
+
   // Configuration for Azure Managed DTS
   // These values should be set as environment variables
   const endpoint = process.env.AZURE_DTS_ENDPOINT;
@@ -31,31 +39,31 @@ import { Task } from "../src/task/task";
 
   // Validate configuration
   if (!connectionString && (!endpoint || !taskHubName)) {
-    console.error(
+    logger.error(
       "Error: Either AZURE_DTS_CONNECTION_STRING or both AZURE_DTS_ENDPOINT and AZURE_DTS_TASKHUB must be set.",
     );
-    console.log("\nUsage:");
-    console.log("  Option 1: Create a .env file in the examples directory (recommended):");
-    console.log(
+    logger.info("\nUsage:");
+    logger.info("  Option 1: Create a .env file in the examples directory (recommended):");
+    logger.info(
       "    AZURE_DTS_CONNECTION_STRING=Endpoint=https://myservice.durabletask.io;Authentication=DefaultAzure;TaskHub=myTaskHub",
     );
-    console.log("    or");
-    console.log("    AZURE_DTS_ENDPOINT=https://myservice.durabletask.io");
-    console.log("    AZURE_DTS_TASKHUB=myTaskHub");
-    console.log("\n  Option 2: Set environment variables directly");
-    console.log("    export AZURE_DTS_CONNECTION_STRING=...");
+    logger.info("    or");
+    logger.info("    AZURE_DTS_ENDPOINT=https://myservice.durabletask.io");
+    logger.info("    AZURE_DTS_TASKHUB=myTaskHub");
+    logger.info("\n  Option 2: Set environment variables directly");
+    logger.info("    export AZURE_DTS_CONNECTION_STRING=...");
     process.exit(1);
   }
 
   // Define an activity function that greets a city
   const greetCity = async (_: ActivityContext, city: string): Promise<string> => {
-    console.log(`Activity executing: greeting ${city}`);
+    logger.info(`Activity executing: greeting ${city}`);
     return `Hello, ${city}!`;
   };
 
   // Define an activity function that processes work items
   const processWorkItem = async (_: ActivityContext, item: string): Promise<number> => {
-    console.log(`Activity executing: processing ${item}`);
+    logger.info(`Activity executing: processing ${item}`);
     // Simulate some processing time
     await new Promise((resolve) => setTimeout(resolve, 500));
     return item.length;
@@ -98,7 +106,7 @@ import { Task } from "../src/task/task";
   try {
     // Create client and worker using connection string or explicit parameters
     if (connectionString) {
-      console.log("Using connection string authentication...");
+      logger.info("Using connection string authentication...");
       client = createAzureManagedClient(connectionString);
       worker = createAzureManagedWorkerBuilder(connectionString)
         .addOrchestrator(sequenceOrchestrator)
@@ -107,7 +115,7 @@ import { Task } from "../src/task/task";
         .addActivity(processWorkItem)
         .build();
     } else {
-      console.log("Using DefaultAzureCredential authentication...");
+      logger.info("Using DefaultAzureCredential authentication...");
       const credential = new DefaultAzureCredential();
       client = createAzureManagedClient(endpoint!, taskHubName!, credential);
       worker = createAzureManagedWorkerBuilder(endpoint!, taskHubName!, credential)
@@ -119,42 +127,42 @@ import { Task } from "../src/task/task";
     }
 
     // Start the worker
-    console.log("Starting worker...");
+    logger.info("Starting worker...");
     await worker.start();
-    console.log("Worker started successfully!");
+    logger.info("Worker started successfully!");
 
     // Run the sequence orchestrator
-    console.log("\n--- Running Sequence Orchestrator ---");
+    logger.info("\n--- Running Sequence Orchestrator ---");
     const sequenceId = await client.scheduleNewOrchestration(sequenceOrchestrator);
-    console.log(`Orchestration scheduled with ID: ${sequenceId}`);
+    logger.info(`Orchestration scheduled with ID: ${sequenceId}`);
 
     const sequenceState = await client.waitForOrchestrationCompletion(sequenceId, undefined, 60);
-    console.log(`Sequence orchestration completed!`);
-    console.log(`Result: ${sequenceState?.serializedOutput}`);
+    logger.info(`Sequence orchestration completed!`);
+    logger.info(`Result: ${sequenceState?.serializedOutput}`);
 
     // Run the fan-out/fan-in orchestrator
-    console.log("\n--- Running Fan-Out/Fan-In Orchestrator ---");
+    logger.info("\n--- Running Fan-Out/Fan-In Orchestrator ---");
     const fanOutId = await client.scheduleNewOrchestration(fanOutFanInOrchestrator);
-    console.log(`Orchestration scheduled with ID: ${fanOutId}`);
+    logger.info(`Orchestration scheduled with ID: ${fanOutId}`);
 
     const fanOutState = await client.waitForOrchestrationCompletion(fanOutId, undefined, 60);
-    console.log(`Fan-out/fan-in orchestration completed!`);
-    console.log(`Result: ${fanOutState?.serializedOutput}`);
+    logger.info(`Fan-out/fan-in orchestration completed!`);
+    logger.info(`Result: ${fanOutState?.serializedOutput}`);
 
-    console.log("\n--- All orchestrations completed successfully! ---");
+    logger.info("\n--- All orchestrations completed successfully! ---");
   } catch (error) {
-    console.error("Error:", error);
+    logger.error("Error:", error);
     process.exit(1);
   } finally {
     // Cleanup: stop worker and client
-    console.log("\nStopping worker and client...");
+    logger.info("\nStopping worker and client...");
     if (worker) {
       await worker.stop();
     }
     if (client) {
       await client.stop();
     }
-    console.log("Cleanup complete.");
+    logger.info("Cleanup complete.");
     process.exit(0);
   }
 })();