js-adapter: fix shared state

Author: phuongdnguyen

example/js/main.ts

@@ -8,7 +8,6 @@ import {
   completeWorkflowSignal,
   getCurrentStatusQuery,
 } from './workflow';
-import * as fs from 'fs/promises';
 import { ReplayMode, setReplayMode, replay, setBreakpoints } from '@temporal/replayer-adapter-nodejs';
 
 // ====================
@@ -87,7 +86,7 @@ async function replayFromFile(historyPath: string = './history.json'): Promise<v
   try {
     // Configure adapter for standalone replay
     setReplayMode(ReplayMode.STANDALONE);
-    // setBreakpoints([3, 9])
+    setBreakpoints([9, 15])
     const opts = {
       historyFilePath: historyPath,
       workerReplayOptions: {
@@ -100,8 +99,9 @@ async function replayFromFile(historyPath: string = './history.json'): Promise<v
           ]
         }
       },
+      name: 'hehe'
     } as any; // adapter types
-
+  
     await replay(opts, exampleWorkflow);
 
     console.log('Replay completed successfully');

replayer-adapter-nodejs/README.md

@@ -93,9 +93,12 @@ await replay(opts, YourWorkflowClass);
 
 ### Using Interceptors Directly
 
+The interceptors are automatically included when using the `replay` function, but you can also use them directly with a Temporal Worker:
+
 ```typescript
 import { Worker } from '@temporalio/worker';
-import { workflowInterceptors, activityInterceptors } from '@temporal/replayer-adapter-nodejs';
+import { interceptors as workflowInterceptors } from '@temporal/replayer-adapter-nodejs/dist/workflow-interceptors';
+import { activityInterceptors } from '@temporal/replayer-adapter-nodejs/dist/activity-interceptors';
 
 const worker = Worker.create({
   taskQueue: 'your-task-queue',
@@ -143,10 +146,10 @@ Replay workflow with history from JSON file.
 ### Interceptors
 
 #### `workflowInterceptors`
-Workflow interceptor factory for debugging support.
+Workflow interceptor factory for debugging support. Automatically injected when using the `replay` function.
 
 #### `activityInterceptors`
-Activity interceptor factory for debugging support.
+Activity interceptor factory for debugging support. Automatically injected when using the `replay` function.
 
 ## Environment Variables
 
@@ -157,7 +160,48 @@ Activity interceptor factory for debugging support.
 See the `example/` directory for complete examples of:
 - Standalone workflow replay with breakpoints
 - IDE-integrated workflow debugging
-- Custom interceptor usage
+
+### Basic Usage Example
+
+```typescript
+import {
+  ReplayMode,
+  ReplayOptions,
+  setReplayMode,
+  setBreakpoints,
+  replay
+} from '@temporal/replayer-adapter-nodejs';
+
+// Example workflow
+async function greetingWorkflow(name: string): Promise<string> {
+  return `Hello, ${name}!`;
+}
+
+async function main() {
+  // Standalone mode
+  setReplayMode(ReplayMode.STANDALONE);
+  setBreakpoints([1, 5, 10]);
+  
+  const standaloneOpts: ReplayOptions = {
+    historyFilePath: './example-history.json',
+    workerReplayOptions: {
+      workflowsPath: require.resolve('./workflows'),
+    }
+  };
+  
+  await replay(standaloneOpts, greetingWorkflow);
+  
+  // IDE mode
+  setReplayMode(ReplayMode.IDE);
+  const ideOpts: ReplayOptions = {
+    workerReplayOptions: {
+      workflowsPath: require.resolve('./workflows'),
+    }
+  };
+  
+  await replay(ideOpts, greetingWorkflow);
+}
+```
 
 ## Architecture
 
@@ -168,12 +212,41 @@ This replayer adapter follows the same architecture as the Go and Python impleme
 3. **HTTP Client**: Communicate with IDE debugger for breakpoint status and highlighting
 4. **History Loading**: Support loading from both JSON files and HTTP endpoints
 
+### Key Components
+
+- **`replayer.ts`**: Main replay logic and breakpoint handling
+- **`workflow-interceptors.ts`**: Workflow interceptors for debugging support
+- **`activity-interceptors.ts`**: Activity interceptors for debugging support
+- **`types.ts`**: Type definitions and state management
+- **`http-client.ts`**: HTTP communication with IDE debugger
+
 ## Compatibility
 
 - Node.js 16.x or higher
-- Temporal TypeScript SDK 1.15.0 or higher
+- Temporal TypeScript SDK 1.12.0 or higher
 - TypeScript 4.9.0 or higher
 
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Development Mode
+
+```bash
+npm run dev
+```
+
+### Clean Build
+
+```bash
+npm run clean
+npm run build
+```
+
 ## Contributing
 
 This package follows the same patterns as the existing Go and Python replayer adapters. When making changes, ensure compatibility across all three implementations.

replayer-adapter-nodejs/src/index.ts

@@ -8,25 +8,15 @@
  * @version 0.1.0
  */
 
-// Export types
-export { ReplayMode, ReplayOptions } from './types';
-
 // Export main functions
 export {
-  setReplayMode,
-  setBreakpoints,
-  isBreakpoint,
-  highlightCurrentEventInIDE,
-  raiseSentinelBreakpoint,
-  getHistoryFromIDE,
   replay,
-  replayWithHistory,
-  replayWithJsonFile,
 } from './replayer';
 
-// Export interceptors
-export { interceptors as workflowInterceptors } from './workflow-interceptors';
-export { activityInterceptors } from './activity-interceptors';
-
-// Export HTTP client utilities
-export { httpGet, httpPost, HttpResponse } from './http-client'; 
+// Export config setters
+export {
+  setBreakpoints,
+  setReplayMode,
+  ReplayMode,
+  ReplayOptions
+} from './types';

replayer-adapter-nodejs/src/replayer.ts

@@ -2,47 +2,27 @@ import * as fs from 'fs/promises';
 import { Worker } from '@temporalio/worker';
 import { historyFromJSON } from '@temporalio/common/lib/proto-utils';
 import { temporal } from '@temporalio/proto';
-import { workflowInfo } from '@temporalio/workflow';
-import { ReplayMode, ReplayOptions } from './types';
+import { getLNSE, ReplayMode, ReplayOptions, setDebuggerAddr, setLNSE, getBreakpoints, getReplayMode, getDebuggerAddr } from './types';
 import { httpGet, httpPost } from './http-client';
 import { activityInterceptors } from './activity-interceptors';
 
-// Global state
-let mode: ReplayMode = ReplayMode.STANDALONE;
-// TODO: make this updatable, currently hard-coded to test other things
-let breakpoints: Set<number> = new Set([9,15]);
-let lastNotifiedStartEvent: number = -1;
-let debuggerAddr: string = '';
 
-/**
- * Set the replay mode (standalone or IDE)
- */
-export function setReplayMode(m: ReplayMode): void {
-  mode = m;
-}
-
-/**
- * Set breakpoints for standalone mode
- */
-export function setBreakpoints(eventIds: number[]): void {
-  breakpoints = new Set(eventIds);
-}
 
 /**
  * Check if the given event ID is a breakpoint
  */
 export function isBreakpoint(eventId: number): boolean {
-  switch (mode) {
+  switch (getReplayMode()) {
     case ReplayMode.STANDALONE:
-      console.log(`Standalone checking breakpoints: ${Array.from(breakpoints)}, eventId: ${eventId}`);
-      if (breakpoints.has(eventId)) {
+      console.log(`Standalone checking breakpoints: ${Array.from(getBreakpoints())}, eventId: ${eventId}`);
+      if (getBreakpoints().has(eventId)) {
         console.log(`Hit breakpoint at eventId: ${eventId}`);
         return true;
       }
       return false;
 
     case ReplayMode.IDE:
-      if (!debuggerAddr) {
+      if (!getDebuggerAddr()) {
         return false;
       }
 
@@ -63,17 +43,17 @@ export function isBreakpoint(eventId: number): boolean {
  * Send highlight request to IDE for current event
  */
 export function highlightCurrentEventInIDE(eventId: number): void {
-  if (!debuggerAddr) {
+  if (!getDebuggerAddr()) {
     console.warn('debuggerAddr is empty, cannot send highlight request');
     return;
   }
 
-  console.log(`Sending highlight request for event ${eventId} to ${debuggerAddr}/current-event`);
+  console.log(`Sending highlight request for event ${eventId} to ${getDebuggerAddr()}/current-event`);
 
   const payload = JSON.stringify({ eventId });
 
   try {
-    sendHighlightRequest(debuggerAddr, payload);
+    sendHighlightRequest(getDebuggerAddr(), payload);
     console.log(`✓ Successfully highlighted event ${eventId} in debugger UI`);
   } catch (error) {
     console.warn(`Failed to send highlight request: ${error}`);
@@ -96,15 +76,15 @@ export function raiseSentinelBreakpoint(caller: string, info?: any): void {
   }
 
   if (eventId !== undefined) {
-    if (eventId <= lastNotifiedStartEvent) {
+    if (eventId <= getLNSE()) {
       return;
     }
-    lastNotifiedStartEvent = eventId;
+    setLNSE(eventId);
     console.log(`runner notified at ${caller}, eventId: ${eventId}`);
 
     if (isBreakpoint(eventId)) {
       console.log(`Pause at event ${eventId}`);
-      if (mode === ReplayMode.IDE) {
+      if (getReplayMode() === ReplayMode.IDE) {
         highlightCurrentEventInIDE(eventId);
       }
         debugger;
@@ -120,13 +100,13 @@ export async function getHistoryFromIDE(): Promise<temporal.api.history.v1.IHist
   const runnerAddr = `http://127.0.0.1:${port}`;
 
   try {
-    const response = await httpGet(`${runnerAddr}/history`);
+    const response = await httpGet(`${getDebuggerAddr()}/history`);
     if (response.statusCode !== 200) {
       throw new Error(`HTTP error! status: ${response.statusCode}`);
     }
 
     const historyData = JSON.parse(response.body);
-    debuggerAddr = runnerAddr;
+    setDebuggerAddr(runnerAddr);
     return historyData;
   } catch (error) {
     console.error(`Could not get history from IDE: ${error}`);
@@ -138,9 +118,9 @@ export async function getHistoryFromIDE(): Promise<temporal.api.history.v1.IHist
  * Main replay function that handles both standalone and IDE modes
  */
 export async function replay(opts: ReplayOptions, workflow: any): Promise<void> {
-  console.log(`Replaying in mode ${mode}`);
+  console.log(`Replaying in mode ${getReplayMode()}`);
 
-  if (mode === ReplayMode.STANDALONE) {
+  if (getReplayMode() === ReplayMode.STANDALONE) {
     console.log('Replaying in standalone mode');
     return replayWithJsonFile(opts.workerReplayOptions || {}, workflow, opts.historyFilePath!);
   } else {
@@ -199,7 +179,7 @@ function checkBreakpointWithIDE(eventId: number): boolean {
   try {
     // This should be an async call in practice, but for simplicity keeping it sync
     // In a production implementation, you'd want to cache breakpoints or make this async
-    const response = httpGet(`${debuggerAddr}/breakpoints`, 2000);
+    const response = httpGet(`${getDebuggerAddr()}/breakpoints`, 2000);
     response.then((res) => {
       if (res.statusCode === 200) {
         const payload = JSON.parse(res.body);

replayer-adapter-nodejs/src/types.ts

@@ -23,4 +23,57 @@ export interface ReplayOptions {
    * Path to the history JSON file (only used in STANDALONE mode)
    */
   historyFilePath?: string;
-} 
+} 
+
+
+export var mode: ReplayMode = ReplayMode.STANDALONE;
+// TODO: make this updatable, currently hard-coded to test other things
+export var breakpoints: Set<number> = new Set([9,15]);
+export var lastNotifiedStartEvent: number = -1;
+export var debuggerAddr: string = '';
+
+
+/**
+ * Set breakpoints for standalone mode
+ */
+export function setBreakpoints(eventIds: number[]): void {
+  breakpoints = new Set(eventIds);
+}
+
+export function getBreakpoints() {
+  return breakpoints;
+}
+
+/**
+ * Set the replay mode (standalone or IDE)
+ */
+export function setReplayMode(m: ReplayMode): void {
+  mode = m;
+}
+
+export function getReplayMode(): ReplayMode {
+  return mode;
+}
+
+/**
+ * Set debugger addr
+ */
+
+export function setDebuggerAddr(addr: string): void {
+  debuggerAddr = addr;
+}
+
+export function getDebuggerAddr(): string {
+  return debuggerAddr;
+}
+
+/**
+ * Set lastNotifiedStartEvent
+ */
+export function setLNSE(eventId: number): void {
+  lastNotifiedStartEvent = eventId;
+}
+
+export function getLNSE(): number {
+  return lastNotifiedStartEvent;
+}