lint and format

activities-stateful/src/activities.ts

@@ -5,7 +5,6 @@
 
 // in a stateful activity, you would do something like this
 export class GreetingActivities {
-
   private count: number;
 
   constructor() {

activities-stateful/src/client.ts

@@ -3,7 +3,6 @@ import { example } from './workflows';
 import { nanoid } from 'nanoid';
 
 async function run() {
-
   const connection = await Connection.connect({ address: 'localhost:7233' });
 
   const client = new Client({

activities-stateful/src/worker.ts

@@ -2,15 +2,13 @@ import { NativeConnection, Worker, WorkerOptions } from '@temporalio/worker';
 // in a stateless activity, you would do something like this
 //import * as activities from './activities';
 // in a stateful activity, you would do something like this
-import {GreetingActivities} from './activities';
+import { GreetingActivities } from './activities';
 
 async function run() {
-
   const connection = await NativeConnection.connect({
     address: 'localhost:7233',
   });
   try {
-
     const greeter = new GreetingActivities();
 
     const x: WorkerOptions = {
@@ -27,7 +25,7 @@ async function run() {
       // your first attempt may be what's written below, but that won't work because
       // you need to bind the method to the instance for `this` to work, as shown above.
       // activities: {greet: greeter.greet},
-    }
+    };
 
     const worker = await Worker.create(x);
 

activities-stateful/src/workflows.ts

@@ -2,23 +2,23 @@ import { proxyActivities, ActivityOptions, RetryPolicy } from '@temporalio/workf
 // in a stateless activity, you would do something like this
 // import type * as activities from './activities';
 // in a stateful activity, you would do something like this
-import {GreetingActivities} from './activities';
+import { GreetingActivities } from './activities';
 
 const retryPolicy: RetryPolicy = {
   backoffCoefficient: 1,
   initialInterval: 5 * 1000,
-}
+};
 
 const activityOptions: ActivityOptions = {
   retry: retryPolicy,
   startToCloseTimeout: 2 * 1000,
-}
+};
 
 // in a stateless activity, you would do something like this
 // const { greet } = proxyActivities<typeof activities>(activityOptions);
 // in a stateful activity, you would do something like this
 const greeter = new GreetingActivities();
-const { greet } = proxyActivities<{greet: typeof greeter.greet}>(activityOptions);
+const { greet } = proxyActivities<{ greet: typeof greeter.greet }>(activityOptions);
 
 export async function example(name: string): Promise<string> {
   return await greet(name);

polling-frequent/src/activities.ts

@@ -2,17 +2,15 @@ import { sleep, heartbeat, log } from '@temporalio/activity';
 import { greetService } from './testService';
 
 export async function greet(name: string): Promise<string> {
-
   // do an infinite loop until the service is ready
-  while (true) {
+  for (;;) {
     try {
-      let greeting = await greetService(name);
+      const greeting = await greetService(name);
       return greeting;
     } catch (err) {
       log.error(String(err));
     }
     heartbeat('invoking activity');
     await sleep(1 * 1000);
   }
-
 }

polling-frequent/src/client.ts

@@ -3,7 +3,6 @@ import { example } from './workflows';
 import { nanoid } from 'nanoid';
 
 async function run() {
-
   const connection = await Connection.connect({ address: 'localhost:7233' });
 
   const client = new Client({

polling-frequent/src/testService.ts

@@ -1,5 +1,3 @@
-
-
 export async function greetService(name: string): Promise<string> {
   const randomVal = Math.random();
 
@@ -9,4 +7,3 @@ export async function greetService(name: string): Promise<string> {
     throw new Error(`Service not ready yet. Random value: ${randomVal.toFixed(2)}`);
   }
 }
-

polling-frequent/src/worker.ts

@@ -2,19 +2,17 @@ import { NativeConnection, Worker, WorkerOptions } from '@temporalio/worker';
 import * as activities from './activities';
 
 async function run() {
-
   const connection = await NativeConnection.connect({
     address: 'localhost:7233',
   });
   try {
-
     const x: WorkerOptions = {
       connection,
       namespace: 'default',
       taskQueue: 'hello-world',
       workflowsPath: require.resolve('./workflows'),
-      activities
-    }
+      activities,
+    };
 
     const worker = await Worker.create(x);
 

polling-frequent/src/workflows.ts

@@ -3,13 +3,12 @@ import type * as activities from './activities';
 
 const activityOptions: ActivityOptions = {
   startToCloseTimeout: 60 * 1000,
-  heartbeatTimeout: 2 * 1000
-}
+  heartbeatTimeout: 2 * 1000,
+};
 
 const { greet } = proxyActivities<typeof activities>(activityOptions);
 
 export async function example(name: string): Promise<string> {
-
-  let result = await greet(name);
-  return result
+  const result = await greet(name);
+  return result;
 }

polling-infrequent/src/client.ts

@@ -3,7 +3,6 @@ import { example } from './workflows';
 import { nanoid } from 'nanoid';
 
 async function run() {
-
   const connection = await Connection.connect({ address: 'localhost:7233' });
 
   const client = new Client({

polling-infrequent/src/testService.ts

@@ -1,5 +1,3 @@
-
-
 export async function greetService(name: string): Promise<string> {
   const randomVal = Math.random();
 
@@ -9,4 +7,3 @@ export async function greetService(name: string): Promise<string> {
     throw new Error(`Service not ready yet. Random value: ${randomVal.toFixed(2)}`);
   }
 }
-

polling-infrequent/src/worker.ts

@@ -2,19 +2,17 @@ import { NativeConnection, Worker, WorkerOptions } from '@temporalio/worker';
 import * as activities from './activities';
 
 async function run() {
-
   const connection = await NativeConnection.connect({
     address: 'localhost:7233',
   });
   try {
-
     const x: WorkerOptions = {
       connection,
       namespace: 'default',
       taskQueue: 'hello-world',
       workflowsPath: require.resolve('./workflows'),
-      activities
-    }
+      activities,
+    };
 
     const worker = await Worker.create(x);
 

polling-infrequent/src/workflows.ts

@@ -4,17 +4,15 @@ import type * as activities from './activities';
 const retryPolicy: RetryPolicy = {
   backoffCoefficient: 1,
   initialInterval: 5 * 1000,
-}
+};
 
 const activityOptions: ActivityOptions = {
   retry: retryPolicy,
   startToCloseTimeout: 2 * 1000,
-}
-
+};
 
 const { greet } = proxyActivities<typeof activities>(activityOptions);
 
 export async function example(name: string): Promise<string> {
-
   return await greet(name);
 }