move examples, use index.ts as playground, update aqua-cli version

src/run-examples.ts

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+import {createClient, registerServiceFunction} from "@fluencelabs/fluence";
+import {testNet} from "@fluencelabs/fluence-network-environment";
+import {callArrowCall} from "./examples/callArrowCall";
+import {dataAliasCall} from "./examples/dataAliasCall";
+import {onCall} from "./examples/onCall";
+import {funcCall} from "./examples/funcCall";
+import {helloWorldCall} from "./examples/helloWorldCall";
+import {foldCall} from "./examples/foldCall";
+import {ifCall} from "./examples/if";
+import {parCall} from "./examples/parCall";
+import {complexCall} from "./examples/complex";
+import {constantsCall} from "./examples/constantsCall";
+import {streamCall} from "./examples/streamCall";
+import {topologyCall} from "./examples/topologyCall";
+let deepEqual = require('deep-equal')
+
+function checkCall(name: string, expected: any, actual: any, callBackOnError: () => void) {
+  if (!deepEqual(actual, expected)) {
+    console.error(`${name} call has the wrong result`)
+    console.error("expected: " + expected)
+    console.error("actual: " + actual)
+    callBackOnError()
+  }
+}
+
+const main = async () => {
+  const client = await createClient(testNet[0]);
+  const client2 = await createClient(testNet[1]);
+
+  // this could be called from `println.aqua`
+  registerServiceFunction(client, "println-service-id", "print", (args: any[], _) => {
+    console.log("println:   " + args[0])
+    return {}
+  })
+
+  // these is only list of calls. Take a look into functions to see what's going on
+
+  // these calls return void, so they could be executed at any time,
+  // because promise waits only a fact that particle was sent
+
+  // callArrow.aqua
+  let callArrowResult = await callArrowCall(client)
+
+  // fold.aqua
+  let foldCallResult = await foldCall(client)
+
+  //if.aqua
+  await ifCall(client)
+
+  // par.aqua
+  let parCallResult = await parCall(client)
+
+  // these calls waiting for a result, so it will be called sequentially
+  // helloWorld.aqua
+  let helloWorldResult = await helloWorldCall(client)
+
+  // func.aqua
+  let funcCallResult = await funcCall(client)
+
+  // on.aqua
+  let onCallResult = await onCall(client)
+
+  // dataAlias.aqua
+  let dataAliasResult = await dataAliasCall(client)
+
+  // complex.aqua
+  let complexCallResult = await complexCall(client)
+
+  // constants.aqua
+  let constantCallResult = await constantsCall(client)
+
+  // stream.aqua
+  let streamResult = await streamCall(client)
+
+  // topology.aqua
+  let topologyResult = await topologyCall(client, client2)
+
+  await client.disconnect();
+
+  let success = true;
+  let cb: () => void = () => {
+    success = false;
+  }
+
+  checkCall("callArrow", callArrowResult, "Hello, callArrow call!", cb)
+
+  checkCall("foldCall", foldCallResult, ["/ip4/165.227.164.206/tcp/7001", "/ip4/165.227.164.206/tcp/9001/ws"], cb)
+
+  checkCall("onCall", onCallResult, ["/ip4/165.227.164.206/tcp/7001", "/ip4/165.227.164.206/tcp/9001/ws"], cb)
+
+  checkCall("parArrow", parCallResult, "hello", cb)
+
+  checkCall("helloWorldCall", helloWorldResult, "Hello, NAME!", cb)
+
+  checkCall("funcCall", funcCallResult, "some str", cb)
+
+  checkCall("dataAliasCall", dataAliasResult, "peer id str", cb)
+
+  checkCall("complexCall", complexCallResult, ["some str", "3", "1", "4", "1", "1", "3", "2", "4", "2", "2"], cb)
+
+  checkCall("constantCall", constantCallResult, "non-default string", cb)
+
+  checkCall("streamCall", streamResult, ["first updated", "second updated", "third updated", "fourth updated"], cb)
+
+  checkCall("topologyCall", topologyResult, "finish", cb)
+
+  if (success) {
+    process.exit(0)
+  } else {
+    process.exit(1)
+  }
+
+};
+
+main().catch((err) => {
+  console.log(err)
+  process.exit(1)
+})