Big refactoring

.gitignore

@@ -12,4 +12,5 @@ bundle/
 
 # Dependency directories
 node_modules/
-jspm_packages/
+jspm_packages/
+/dist/

package.json

@@ -2,15 +2,12 @@
   "name": "@fluencelabs/fluence",
   "version": "0.8.0",
   "description": "JS SDK for the Fluence network",
-  "main": "./dist/fluence.js",
-  "typings": "./dist/fluence.d.ts",
+  "main": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
   "scripts": {
     "test": "mocha --timeout 10000 -r esm -r ts-node/register src/**/*.spec.ts",
-    "test-ts": "ts-mocha --timeout 10000 -r esm -p tsconfig.json src/**/*.spec.ts",
-    "package:build": "NODE_ENV=production webpack && npm run package",
-    "package": "tsc && rsync -r src/aqua/*.js dist/aqua",
-    "start": "webpack-dev-server -p",
-    "build": "webpack --mode production"
+    "build": "tsc && rsync -r src/internal/aqua/*.js dist/internal/aqua",
+    "build:webpack": "webpack --mode production"
   },
   "repository": "https://github.com/fluencelabs/fluence-js",
   "author": "Fluence Labs",
@@ -48,7 +45,7 @@
     "text-encoding": "^0.7.0",
     "ts-loader": "7.0.5",
     "ts-mocha": "8.0.0",
-    "typescript": "3.9.5",
+    "typescript": "^3.9.5",
     "webpack": "4.43.0",
     "webpack-cli": "3.3.11",
     "webpack-dev-server": "3.11.0"

src/FluenceClient.ts

@@ -0,0 +1,252 @@
+/*
+ * Copyright 2020 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import log from 'loglevel';
+import PeerId from 'peer-id';
+import { SecurityTetraplet, StepperOutcome } from './internal/commonTypes';
+import { FluenceClientBase } from './internal/FluenceClientBase';
+import { build, genUUID, ParticleDto } from './internal/particle';
+import { ParticleProcessor } from './internal/ParticleProcessor';
+import { ParticleProcessorStrategy } from './internal/ParticleProcessorStrategy';
+
+const fetchCallbackServiceName = '__callback';
+const selfRelayVarName = '__relay';
+
+const wrapRelayBasedCall = (script: string) => {
+    return `
+    (seq
+        (call ${selfRelayVarName} ("op" "identity") [])
+        ${script}
+    )
+    `;
+};
+
+const wrapFetchCall = (script: string, particleId: string, resultArgNames: string[]) => {
+    // TODO: sanitize
+    const resultTogether = resultArgNames.join(' ');
+    let res = `
+    (seq
+        ${script}
+        (seq
+            (call ${selfRelayVarName} ("op" "identity") [])
+            (call %init_peer_id%  ("${fetchCallbackServiceName}" "${particleId}") [${resultTogether}])
+        )
+    )`;
+    return wrapRelayBasedCall(res);
+};
+
+export interface FluenceEvent {
+    type: string;
+    args: any[];
+}
+
+export type FluenceEventHandler = (event: FluenceEvent) => void;
+
+export class FluenceClient extends FluenceClientBase {
+    private eventSubscribers: Map<string, FluenceEventHandler[]> = new Map();
+    private eventValidators: Map<string, Function> = new Map();
+    private callbacks: Map<string, Function> = new Map();
+    private fetchParticles: Map<string, { resolve: Function; reject: Function }> = new Map();
+
+    constructor(selfPeerId: PeerId) {
+        super(selfPeerId);
+        this.processor = new ParticleProcessor(this.strategy, selfPeerId);
+    }
+
+    async fetch<T>(script: string, resultArgNames: string[], data?: Map<string, any>, ttl?: number): Promise<T> {
+        data = this.addRelayToArgs(data);
+        const callBackId = genUUID();
+        script = wrapFetchCall(script, callBackId, resultArgNames);
+        const particle = await build(this.selfPeerIdFull, script, data, ttl, callBackId);
+
+        return new Promise<T>((resolve, reject) => {
+            this.fetchParticles.set(callBackId, { resolve, reject });
+            this.processor.executeLocalParticle(particle);
+        });
+    }
+
+    // TODO:: better naming probably?
+    async fireAndForget(script: string, data?: Map<string, any>, ttl?: number) {
+        data = this.addRelayToArgs(data);
+        script = wrapRelayBasedCall(script);
+
+        await this.sendScript(script, data, ttl);
+    }
+
+    registerEvent(
+        channel: string,
+        eventName: string,
+        validate?: (channel: string, eventName: string, args: any[], tetraplets: any[][]) => boolean,
+    ) {
+        if (!validate) {
+            validate = (c, e, a, t) => true;
+        }
+
+        this.eventValidators.set(`${channel}/${eventName}`, validate);
+    }
+
+    unregisterEvent(channel: string, eventName: string) {
+        this.eventValidators.delete(`${channel}/${eventName}`);
+    }
+
+    registerCallback(
+        serviceId: string,
+        fnName: string,
+        callback: (args: any[], tetraplets: SecurityTetraplet[][]) => object,
+    ) {
+        this.callbacks.set(`${serviceId}/${fnName}`, callback);
+    }
+
+    unregisterCallback(channel: string, eventName: string) {
+        this.eventValidators.delete(`${channel}/${eventName}`);
+    }
+
+    subscribe(channel: string, handler: FluenceEventHandler) {
+        if (!this.eventSubscribers.get(channel)) {
+            this.eventSubscribers.set(channel, []);
+        }
+
+        this.eventSubscribers.get(channel).push(handler);
+    }
+
+    protected strategy: ParticleProcessorStrategy = {
+        particleHandler: (serviceId: string, fnName: string, args: any[], tetraplets: SecurityTetraplet[][]) => {
+            // missing built-in op
+            if (serviceId === 'op' && fnName === 'identity') {
+                return {
+                    ret_code: 0,
+                    result: JSON.stringify(args),
+                };
+            }
+
+            // async fetch model handling
+            if (serviceId === fetchCallbackServiceName) {
+                const executingParticlePromiseFns = this.fetchParticles.get(fnName);
+                if (executingParticlePromiseFns) {
+                    // don't block
+                    setImmediate(() => {
+                        this.fetchParticles.delete(fnName);
+                        executingParticlePromiseFns.resolve(args);
+                    });
+                }
+
+                return {
+                    ret_code: 0,
+                    result: JSON.stringify({}),
+                };
+            }
+
+            // event model handling
+            const eventPair = `${serviceId}/${fnName}`;
+            const eventValidator = this.eventValidators.get(eventPair);
+            if (eventValidator) {
+                try {
+                    if (!eventValidator(serviceId, fnName, args, tetraplets)) {
+                        return {
+                            ret_code: 1, // TODO:: error codes
+                            result: 'validation failed',
+                        };
+                    }
+                } catch (e) {
+                    log.error('error running validation function: ' + e);
+                    return {
+                        ret_code: 1, // TODO:: error codes
+                        result: 'validation failed',
+                    };
+                }
+
+                // don't block
+                setImmediate(() => {
+                    this.pushEvent(serviceId, {
+                        type: fnName,
+                        args: args,
+                    });
+                });
+
+                return {
+                    ret_code: 0,
+                    result: JSON.stringify({}),
+                };
+            }
+
+            // callback model handling
+            const callback = this.callbacks.get(eventPair);
+            if (callback) {
+                try {
+                    const res = callback(args, tetraplets);
+                    return {
+                        ret_code: 0,
+                        result: JSON.stringify(res),
+                    };
+                } catch (e) {
+                    return {
+                        ret_code: 1, // TODO:: error codes
+                        result: JSON.stringify(e),
+                    };
+                }
+            }
+
+            return {
+                ret_code: 1,
+                result: `Error. There is no service: ${serviceId}`,
+            };
+        },
+
+        sendParticleFurther: async (particle: ParticleDto) => {
+            try {
+                await this.connection.sendParticle(particle);
+            } catch (reason) {
+                log.error(`Error on sending particle with id ${particle.id}: ${reason}`);
+            }
+        },
+
+        onParticleTimeout: (particle: ParticleDto, now: number) => {
+            log.info(`Particle expired. Now: ${now}, ttl: ${particle.ttl}, ts: ${particle.timestamp}`);
+            const executingParticle = this.fetchParticles.get(particle.id);
+            if (executingParticle) {
+                executingParticle.reject(new Error(`particle ${particle.id} timed out`));
+            }
+        },
+        onLocalParticleRecieved: (particle: ParticleDto) => {},
+        onExternalParticleRecieved: (particle: ParticleDto) => {},
+        onStepperExecuting: (particle: ParticleDto) => {},
+        onStepperExecuted: (stepperOutcome: StepperOutcome) => {
+            log.info('inner interpreter outcome:');
+            log.info(stepperOutcome);
+        },
+    };
+
+    private pushEvent(channel: string, event: FluenceEvent) {
+        const subs = this.eventSubscribers.get(channel);
+        if (subs) {
+            for (let sub of subs) {
+                sub(event);
+            }
+        }
+    }
+
+    private addRelayToArgs(data: Map<string, any>) {
+        if (data === undefined) {
+            data = new Map();
+        }
+
+        if (!data.has(selfRelayVarName)) {
+            data.set(selfRelayVarName, this.relayPeerId);
+        }
+
+        return data;
+    }
+}