Merge pull request #179 from Azure/dev

Updating release version to 1.4.0

Author: davidmrdavid

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "durable-functions",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "description": "Durable Functions library for Node.js Azure Functions",
   "license": "MIT",
   "repository": {
@@ -37,30 +37,31 @@
     "debug": "~2.6.9",
     "lodash": "^4.17.15",
     "rimraf": "~2.5.4",
+    "typedoc": "^0.17.1",
     "uuid": "~3.3.2",
     "validator": "~10.8.0"
   },
   "devDependencies": {
     "@types/chai": "~4.1.6",
-    "@types/chai-string": "~1.4.1",
     "@types/chai-as-promised": "~7.1.0",
+    "@types/chai-string": "~1.4.1",
     "@types/commander": "~2.3.31",
     "@types/debug": "0.0.29",
-    "@types/mocha": "~5.2.5",
+    "@types/mocha": "~7.0.2",
     "@types/nock": "^9.3.0",
     "@types/node": "~6.14.7",
     "@types/rimraf": "0.0.28",
     "@types/sinon": "~5.0.5",
     "chai": "~4.2.0",
-    "chai-string": "~1.5.0",
     "chai-as-promised": "~7.1.1",
-    "mocha": "~5.2.0",
+    "chai-string": "~1.5.0",
+    "mocha": "~7.1.1",
     "moment": "~2.22.2",
     "nock": "^10.0.6",
     "sinon": "~7.1.1",
     "ts-node": "~1.0.0",
     "tslint": "^5.11.0",
-    "typescript": "~3.2.4"
+    "typescript": "^3.8.3"
   },
   "engines": {
     "node": ">=6.5.0"

package.json

@@ -0,0 +1,10 @@
+{
+    "bindings": [
+      {
+        "name": "context",
+        "type": "entityTrigger",
+        "direction": "in"
+      }
+    ],
+    "disabled": false
+  }

samples/AsyncCounterEntity/functions.json

@@ -0,0 +1,21 @@
+const df = require("durable-functions");
+
+module.exports = df.entity(async function(context) {
+    await Promise.resolve();
+    let currentValue = context.df.getState(() => 0);
+
+    switch (context.df.operationName) {
+        case "add":
+            const amount = context.df.getInput();
+            currentValue += amount;
+            break;
+        case "reset":
+            currentValue = 0;
+            break;
+        case "get":
+            context.df.return(currentValue);
+            break;
+    }
+
+    context.df.setState(currentValue);
+});

samples/AsyncCounterEntity/index.js

@@ -0,0 +1,10 @@
+{
+  "bindings": [
+    {
+      "name": "context",
+      "type": "orchestrationTrigger",
+      "direction": "in"
+    }
+  ],
+  "disabled": false
+}

samples/AsyncCounterOrchestration/function.json

@@ -0,0 +1,10 @@
+const df = require("durable-functions");
+
+module.exports = df.orchestrator(function*(context){
+    const entityId = new df.EntityId("AsyncCounterEntity", "myAsyncCounter");
+
+    currentValue = yield context.df.callEntity(entityId, "get");
+    if (currentValue < 10) {
+        yield context.df.callEntity(entityId, "add", 1);
+    }
+});

samples/AsyncCounterOrchestration/index.js

@@ -1,4 +1,4 @@
-import { ActionType, DurableHttpRequest, IAction, Utils } from "../classes";
+import { ActionType, DurableHttpRequest, IAction } from "../classes";
 
 /** @hidden */
 export class CallHttpAction implements IAction {

src/actions/callhttpaction.ts

@@ -1,5 +1,5 @@
 import { isDate } from "util";
-import { ActionType, Constants, IAction } from "../classes";
+import { ActionType, IAction } from "../classes";
 
 /** @hidden */
 export class CreateTimerAction implements IAction {

src/actions/createtimeraction.ts

@@ -465,7 +465,7 @@ export class DurableOrchestrationClient {
             case 200:   // entity exists
                 return new EntityStateResponse(true, response.data as T);
             case 404:   // entity does not exist
-                return new EntityStateResponse(false, undefined);
+                return new EntityStateResponse(false);
             default:
                 return Promise.reject(this.createGenericError(response));
         }

src/durableorchestrationclient.ts

@@ -15,6 +15,17 @@ export class DurableOrchestrationContext {
      */
     public readonly instanceId: string;
 
+    /**
+     * The ID of the parent orchestration of the current sub-orchestration
+     * instance. The value will be available only in sub-orchestrations.
+     *
+     * The parent instance ID is generated and fixed when the parent
+     * orchestrator function is scheduled. It can be either auto-generated, in
+     * which case it is formatted as a GUID, or it can be user-specified with
+     * any format.
+     */
+    public readonly parentInstanceId: string | undefined;
+
     /**
      * Gets a value indicating whether the orchestrator function is currently
      * replaying itself.
@@ -26,18 +37,7 @@ export class DurableOrchestrationContext {
      * whether the function is being replayed and then issue the log statements
      * when this value is `false`.
      */
-    public readonly isReplaying: boolean;
-
-    /**
-     * The ID of the parent orchestration of the current sub-orchestration
-     * instance. The value will be available only in sub-orchestrations.
-     *
-     * The parent instance ID is generated and fixed when the parent
-     * orchestrator function is scheduled. It can be either auto-generated, in
-     * which case it is formatted as a GUID, or it can be user-specified with
-     * any format.
-     */
-    public readonly parentInstanceId: string | undefined;
+    public isReplaying: boolean;
 
     /**
      * Gets the current date/time in a way that is safe for use by orchestrator

src/durableorchestrationcontext.ts

@@ -7,6 +7,6 @@ export class EntityStateResponse<T> {
         public entityExists: boolean,
 
         /** The current state of the entity, if it exists, or default value otherwise. */
-        public entityState: T | undefined,
+        public entityState?: T,
     ) {}
 }

src/entities/entitystateresponse.ts

@@ -30,7 +30,7 @@ export class Entity {
             context.df = this.getCurrentDurableEntityContext(entityBinding, returnState, i, startTime);
 
             try {
-                this.fn(context);
+                await Promise.resolve(this.fn(context));
                 if (!returnState.results[i]) {
                     const elapsedMs = this.computeElapsedMilliseconds(startTime);
                     returnState.results[i] = new OperationResult(false, elapsedMs);

src/entity.ts

@@ -25,7 +25,7 @@ export class Orchestrator {
     private newGuidCounter: number;
     private subOrchestratorCounter: number;
 
-    constructor(public fn: (context: IOrchestrationFunctionContext) => IterableIterator<unknown>) { }
+    constructor(public fn: (context: IOrchestrationFunctionContext) => Generator<unknown, unknown, any>) { }
 
     public listen() {
         return this.handle.bind(this);
@@ -87,7 +87,7 @@ export class Orchestrator {
 
         try {
             // First execution, we have not yet "yielded" any of the tasks.
-            let g = gen.next(undefined);
+            let g = gen.next();
 
             while (true) {
 
@@ -146,6 +146,13 @@ export class Orchestrator {
                     return;
                 }
 
+                // The first time a task is marked as complete, the history event that finally marked the task as completed
+                // should not yet have been played by the Durable Task framework, resulting in isReplaying being false.
+                // On replays, the event will have already been processed by the framework, and IsPlayed will be marked as true.
+                if (state[partialResult.completionIndex] !== undefined) {
+                  context.df.isReplaying = state[partialResult.completionIndex].IsPlayed;
+                }
+
                 if (TaskFilter.isFailedTask(partialResult)) {
                     if (!gen.throw) {
                         throw new Error("Cannot properly throw the execption returned by customer code");
@@ -544,11 +551,10 @@ export class Orchestrator {
     }
 
     private all(state: HistoryEvent[], tasks: TaskBase[]): TaskSet {
-        let maxCompletionIndex: number | undefined = undefined;
+        let maxCompletionIndex: number | undefined;
         const errors: Error[] = [];
-        const results: unknown[] = [];
-        for (let index = 0; index < tasks.length; index++) {
-            const task = tasks[index];
+        const results: Array<unknown> = [];
+        for (const task of tasks) {
             if (!TaskFilter.isCompletedTask(task)) {
                 return TaskFactory.UncompletedTaskSet(tasks);
             }
@@ -582,9 +588,8 @@ export class Orchestrator {
             throw new Error("At least one yieldable task must be provided to wait for.");
         }
 
-        let firstCompleted: CompletedTask | undefined = undefined;
-        for (let index = 0; index < tasks.length; index++) {
-            const task = tasks[index];
+        let firstCompleted: CompletedTask | undefined;
+        for (const task of tasks) {
             if (TaskFilter.isCompletedTask(task)) {
                 if (!firstCompleted) {
                     firstCompleted = task;

src/orchestrator.ts

@@ -14,7 +14,7 @@ import { Entity, IEntityFunctionContext, IOrchestrationFunctionContext, Orchestr
  * });
  * ```
  */
-export function orchestrator(fn: (context: IOrchestrationFunctionContext) => IterableIterator<unknown>)
+export function orchestrator(fn: (context: IOrchestrationFunctionContext) => Generator<unknown, unknown, any>)
     : (context: IOrchestrationFunctionContext) => void {
     const listener = new Orchestrator(fn).listen();
     return (context: IOrchestrationFunctionContext) => {
@@ -25,7 +25,7 @@ export function orchestrator(fn: (context: IOrchestrationFunctionContext) => Ite
 export function entity(fn: (context: IEntityFunctionContext) => unknown)
     : (context: IEntityFunctionContext) => void {
     const listener = new Entity(fn).listen();
-    return (context: IEntityFunctionContext) => {
-        listener(context);
+    return async (context: IEntityFunctionContext) => {
+        await listener(context);
     };
 }

src/shim.ts

@@ -18,7 +18,7 @@ describe("Entity", () => {
         const mockContext = new MockContext({
             context: testData.input,
         });
-        entity(mockContext);
+        await entity(mockContext);
 
         expect(mockContext.doneValue).to.not.equal(undefined);
 
@@ -36,7 +36,28 @@ describe("Entity", () => {
         const mockContext = new MockContext({
             context: testData.input,
         });
-        entity(mockContext);
+        await entity(mockContext);
+
+        expect(mockContext.doneValue).to.not.equal(undefined);
+
+        if (mockContext.doneValue) {
+            entityStateMatchesExpected(mockContext.doneValue, testData.output);
+        }
+    });
+
+    it("AsyncStringStore entity with no initial state.", async () => {
+        const entity = TestEntities.AsyncStringStore;
+        const operations: StringStoreOperation[] = [];
+        operations.push({ kind: "set", value: "set 1"});
+        operations.push({ kind: "get"});
+        operations.push({ kind: "set", value: "set 2"});
+        operations.push({ kind: "get"});
+
+        const testData = TestEntityBatches.GetAsyncStringStoreBatch(operations, undefined);
+        const mockContext = new MockContext({
+            context: testData.input,
+        });
+        await entity(mockContext);
 
         expect(mockContext.doneValue).to.not.equal(undefined);
 

test/integration/entity-spec.ts

@@ -8,8 +8,8 @@ import {
     ActionType, CallActivityAction, CallActivityWithRetryAction, CallEntityAction, CallHttpAction, CallSubOrchestratorAction,
     CallSubOrchestratorWithRetryAction, ContinueAsNewAction, CreateTimerAction, DurableHttpRequest,
     DurableHttpResponse, DurableOrchestrationBindingInfo, DurableOrchestrationContext, EntityId,
-    ExternalEventType, IOrchestratorState, LockState, OrchestratorState,
-    RetryOptions, WaitForExternalEventAction,
+    ExternalEventType, HistoryEvent, IOrchestratorState, LockState,
+    OrchestratorState, RetryOptions, WaitForExternalEventAction,
 } from "../../src/classes";
 import { OrchestrationFailureError } from "../../src/orchestrationfailureerror";
 import { TestHistories } from "../testobjects/testhistories";
@@ -119,23 +119,18 @@ describe("Orchestrator", () => {
         it("assigns isReplaying", async () => {
             const orchestrator = TestOrchestrations.SayHelloSequence;
             const name = "World";
-            const replaying = true;
+
+            const mockHistory = TestHistories.GetSayHelloWithActivityReplayOne("SayHelloWithActivity", moment.utc().toDate(), name);
 
             const mockContext = new MockContext({
-                context: new DurableOrchestrationBindingInfo(
-                    TestHistories.GetSayHelloWithActivityReplayOne(
-                        "SayHelloWithActivity",
-                        moment.utc().toDate(),
-                        name),
-                    name,
-                    undefined,
-                    replaying,
-                ),
+              context: new DurableOrchestrationBindingInfo(mockHistory, name),
             });
 
             orchestrator(mockContext);
 
-            expect(mockContext.df!.isReplaying).to.be.equal(replaying);
+            const lastEvent = mockHistory.pop() as HistoryEvent;
+
+            expect(mockContext.df!.isReplaying).to.be.equal(lastEvent.IsPlayed);
         });
 
         it("assigns parentInstanceId", async () => {

test/integration/orchestrator-spec.ts

@@ -305,13 +305,11 @@ export class TestOrchestrations {
         return "Timer fired!";
     });
 
-    public static ThrowsExceptionFromActivity: any = df.orchestrator(function*(context: any)
-    : IterableIterator<unknown> {
+    public static ThrowsExceptionFromActivity: any = df.orchestrator(function*(context: any) {
         yield context.df.callActivity("ThrowsErrorActivity");
     });
 
-    public static ThrowsExceptionFromActivityWithCatch: any = df.orchestrator(function*(context: any)
-    : IterableIterator<unknown> {
+    public static ThrowsExceptionFromActivityWithCatch: any = df.orchestrator(function*(context: any) {
         try {
             yield context.df.callActivity("ThrowsErrorActivity");
         } catch (e) {
@@ -322,8 +320,7 @@ export class TestOrchestrations {
         }
     });
 
-    public static ThrowsExceptionInline: any = df.orchestrator(function*(context: any)
-    : IterableIterator<unknown> {
+    public static ThrowsExceptionInline: any = df.orchestrator(function*(context: any) {
         throw Error("Exception from Orchestrator");
     });
 }

test/testobjects/TestOrchestrations.ts

@@ -38,4 +38,19 @@ export class TestEntities {
                 throw Error("Invalid operation");
         }
     });
+
+    public static AsyncStringStore: any = df.entity(async (context: IEntityFunctionContext) => {
+        await new Promise((resolve) => setTimeout(() => resolve(), 0)); // force onto the event loop and result in a no-op delay
+        switch (context.df.operationName) {
+            case "set":
+                context.df.setState(context.df.getInput());
+                break;
+            case "get":
+                context.df.return(context.df.getState());
+                break;
+            default:
+                throw new Error("No such operation exists");
+        }
+
+    });
 }