gauge-ts 0.0.4 → 0.1.1

package/dist/GaugeRuntime.d.ts

@@ -1,4 +1,3 @@
 export declare class GaugeRuntime {
-    private lspProtoPath;
-    start(): Promise<void>;
+    start(): void;
 }

package/dist/GaugeRuntime.js

@@ -1,43 +1,23 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const proto_loader_1 = require("@grpc/proto-loader");
-const grpc_1 = require("grpc");
-const path_1 = require("path");
-const GaugeListener_1 = require("./connection/GaugeListener");
-const GRPCHandler_1 = require("./connection/GRPCHandler");
+const grpc_js_1 = require("@grpc/grpc-js");
+const services_grpc_pb_1 = require("./gen/services_grpc_pb");
 const StaticLoader_1 = require("./loaders/StaticLoader");
-const MessageProcessorFactory_1 = require("./processors/MessageProcessorFactory");
+const RunnerServiceImpl_1 = require("./RunnerServiceImpl");
 class GaugeRuntime {
-    constructor() {
-        this.lspProtoPath = path_1.join(__dirname, 'gen', 'lsp.proto');
-    }
     start() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let loader = new StaticLoader_1.StaticLoader();
-            loader.loadImplementations();
-            let factory = new MessageProcessorFactory_1.MessageProcessorFactory(loader);
-            if (process.env.GAUGE_LSP_GRPC) {
-                let pd = proto_loader_1.loadSync(this.lspProtoPath);
-                let lspService = grpc_1.loadPackageDefinition(pd).gauge.messages.lspService.service;
-                let server = new grpc_1.Server();
-                server.addService(lspService, new GRPCHandler_1.GRPCHandler(server, factory));
-                var p = server.bind("127.0.0.1:0", grpc_1.ServerCredentials.createInsecure());
-                console.log("Listening on port:" + p);
-                server.start();
-            }
-            else {
-                let listener = new GaugeListener_1.GaugeListener(factory);
-                listener.pollForMessages();
+        const loader = new StaticLoader_1.StaticLoader();
+        loader.loadImplementations();
+        const server = new grpc_js_1.Server();
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        server.addService(services_grpc_pb_1.RunnerService, new RunnerServiceImpl_1.RunnerServiceImpl(server, loader));
+        server.bindAsync("127.0.0.1:0", grpc_js_1.ServerCredentials.createInsecure(), (err, port) => {
+            if (err) {
+                throw err;
             }
+            console.log(`Listening on port:${port}`);
+            server.start();
         });
     }
 }

package/dist/RunnerServiceImpl.d.ts

@@ -0,0 +1,48 @@
+import { sendUnaryData as sUD, Server, ServerUnaryCall as SUC } from "@grpc/grpc-js";
+import { CacheFileRequest, Empty, ExecuteStepRequest, ExecutionEndingRequest, ExecutionStartingRequest, ExecutionStatusResponse as ESR, FileDiff, ImplementationFileGlobPatternResponse as IFGPR, ImplementationFileListResponse as IFLR, KillProcessRequest, RefactorRequest, RefactorResponse, ScenarioDataStoreInitRequest as SCDSIR, ScenarioExecutionEndingRequest as SCEER, ScenarioExecutionStartingRequest as SCESR, SpecDataStoreInitRequest as SPDSIR, SpecExecutionEndingRequest as SPEER, SpecExecutionStartingRequest as SPESR, StepExecutionEndingRequest as STEER, StepExecutionStartingRequest as STESR, StepNameRequest, StepNameResponse, StepNamesRequest, StepNamesResponse, StepPositionsRequest, StepPositionsResponse, StepValidateRequest, StepValidateResponse, StubImplementationCodeRequest, SuiteDataStoreInitRequest } from "./gen/messages_pb";
+import { IRunnerServer } from "./gen/services_grpc_pb";
+import { StaticLoader } from "./loaders/StaticLoader";
+export declare class RunnerServiceImpl implements IRunnerServer {
+    private readonly _server;
+    private readonly _loader;
+    private _stepValidateRequestProcessor;
+    private _stepNameRequestProcessor;
+    private _refactorRequestProcessor;
+    private _cacheFileRequestProcessor;
+    private _stubImplementationCodeRequestProcessor;
+    private _stepPositionsRequestProcessor;
+    private _executionStartingProcessor;
+    private _executionEndingProcessor;
+    private _specExecutionStartingProcessor;
+    private _specExecutionEndingProcessor;
+    private _scenarioExecutionStartingProcessor;
+    private _scenarioExecutionEndingProcessor;
+    private _stepExecutionStartingProcessor;
+    private _stepExecutionEndingProcessor;
+    private _executeStepProcessor;
+    constructor(server: Server, loader: StaticLoader);
+    validateStep(call: SUC<StepValidateRequest, StepValidateResponse>, callback: sUD<StepValidateResponse>): void;
+    initializeSuiteDataStore(call: SUC<SuiteDataStoreInitRequest, ESR>, callback: sUD<ESR>): void;
+    startExecution(call: SUC<ExecutionStartingRequest, ESR>, callback: sUD<ESR>): void;
+    initializeSpecDataStore(call: SUC<SPDSIR, ESR>, callback: sUD<ESR>): void;
+    startSpecExecution(call: SUC<SPESR, ESR>, callback: sUD<ESR>): void;
+    initializeScenarioDataStore(call: SUC<SCDSIR, ESR>, callback: sUD<ESR>): void;
+    startScenarioExecution(call: SUC<SCESR, ESR>, callback: sUD<ESR>): void;
+    startStepExecution(call: SUC<STESR, ESR>, callback: sUD<ESR>): void;
+    executeStep(call: SUC<ExecuteStepRequest, ESR>, callback: sUD<ESR>): void;
+    finishStepExecution(call: SUC<STEER, ESR>, callback: sUD<ESR>): void;
+    finishScenarioExecution(call: SUC<SCEER, ESR>, callback: sUD<ESR>): void;
+    finishSpecExecution(call: SUC<SPEER, ESR>, callback: sUD<ESR>): void;
+    finishExecution(call: SUC<ExecutionEndingRequest, ESR>, callback: sUD<ESR>): void;
+    cacheFile(call: SUC<CacheFileRequest, Empty>, callback: sUD<Empty>): void;
+    getStepName(call: SUC<StepNameRequest, StepNameResponse>, callback: sUD<StepNameResponse>): void;
+    getGlobPatterns(call: SUC<Empty, IFGPR>, callback: sUD<IFGPR>): void;
+    getStepNames(call: SUC<StepNamesRequest, StepNamesResponse>, callback: sUD<StepNamesResponse>): void;
+    getStepPositions(call: SUC<StepPositionsRequest, StepPositionsResponse>, callback: sUD<StepPositionsResponse>): void;
+    getImplementationFiles(call: SUC<Empty, IFLR>, callback: sUD<IFLR>): void;
+    implementStub(call: SUC<StubImplementationCodeRequest, FileDiff>, callback: sUD<FileDiff>): void;
+    refactor(call: SUC<RefactorRequest, RefactorResponse>, callback: sUD<RefactorResponse>): void;
+    kill(_call: SUC<KillProcessRequest, Empty>, callback: sUD<Empty>): void;
+    private createRpcError;
+    private getEmptExecutionResponse;
+}

package/dist/RunnerServiceImpl.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@grpc/grpc-js/build/src/constants");
+const path_1 = require("path");
+const os_1 = require("os");
+const _1 = require(".");
+const messages_pb_1 = require("./gen/messages_pb");
+const spec_pb_1 = require("./gen/spec_pb");
+const ImplLoader_1 = require("./loaders/ImplLoader");
+const StepRegistry_1 = require("./models/StepRegistry");
+const CacheFileProcessor_1 = require("./processors/CacheFileProcessor");
+const ExecutionEndingProcessor_1 = require("./processors/ExecutionEndingProcessor");
+const ExecutionStartingProcessor_1 = require("./processors/ExecutionStartingProcessor");
+const RefactorProcessor_1 = require("./processors/RefactorProcessor");
+const ScenarioExecutionEndingProcessor_1 = require("./processors/ScenarioExecutionEndingProcessor");
+const ScenarioExecutionStartingProcessor_1 = require("./processors/ScenarioExecutionStartingProcessor");
+const SpecExecutionEndingProcessor_1 = require("./processors/SpecExecutionEndingProcessor");
+const SpecExecutionStartingProcessor_1 = require("./processors/SpecExecutionStartingProcessor");
+const StepExecutionEndingProcessor_1 = require("./processors/StepExecutionEndingProcessor");
+const StepExecutionProcessor_1 = require("./processors/StepExecutionProcessor");
+const StepExecutionStartingProcessor_1 = require("./processors/StepExecutionStartingProcessor");
+const StepNameProcessor_1 = require("./processors/StepNameProcessor");
+const StepPositionsProcessor_1 = require("./processors/StepPositionsProcessor");
+const StubImplementationCodeProcessor_1 = require("./processors/StubImplementationCodeProcessor");
+const ValidationProcessor_1 = require("./processors/ValidationProcessor");
+const Util_1 = require("./utils/Util");
+class RunnerServiceImpl {
+    constructor(server, loader) {
+        this._server = server;
+        this._loader = loader;
+        this._stepValidateRequestProcessor = new ValidationProcessor_1.ValidationProcessor();
+        this._stepNameRequestProcessor = new StepNameProcessor_1.StepNameProcessor();
+        this._refactorRequestProcessor = new RefactorProcessor_1.RefactorProcessor();
+        this._cacheFileRequestProcessor = new CacheFileProcessor_1.CacheFileProcessor(this._loader);
+        this._stubImplementationCodeRequestProcessor = new StubImplementationCodeProcessor_1.StubImplementationCodeProcessor();
+        this._stepPositionsRequestProcessor = new StepPositionsProcessor_1.StepPositionsProcessor();
+        this._executionStartingProcessor = new ExecutionStartingProcessor_1.ExecutionStartingProcessor();
+        this._executionEndingProcessor = new ExecutionEndingProcessor_1.ExecutionEndingProcessor();
+        this._specExecutionStartingProcessor = new SpecExecutionStartingProcessor_1.SpecExecutionStartingProcessor();
+        this._specExecutionEndingProcessor = new SpecExecutionEndingProcessor_1.SpecExecutionEndingProcessor();
+        this._scenarioExecutionStartingProcessor = new ScenarioExecutionStartingProcessor_1.ScenarioExecutionStartingProcessor();
+        this._scenarioExecutionEndingProcessor = new ScenarioExecutionEndingProcessor_1.ScenarioExecutionEndingProcessor();
+        this._stepExecutionStartingProcessor = new StepExecutionStartingProcessor_1.StepExecutionStartingProcessor();
+        this._stepExecutionEndingProcessor = new StepExecutionEndingProcessor_1.StepExecutionEndingProcessor();
+        this._executeStepProcessor = new StepExecutionProcessor_1.StepExecutionProcessor();
+    }
+    validateStep(call, callback) {
+        try {
+            callback(null, this._stepValidateRequestProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    initializeSuiteDataStore(call, callback) {
+        try {
+            _1.DataStoreFactory.getSuiteDataStore().clear();
+            const loader = new ImplLoader_1.ImplLoader();
+            loader.loadImplementations()
+                .then(() => callback(null, this.getEmptExecutionResponse()))
+                .catch((err) => {
+                callback(this.createRpcError(err), null);
+            });
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    startExecution(call, callback) {
+        this._executionStartingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    initializeSpecDataStore(call, callback) {
+        try {
+            _1.DataStoreFactory.getSpecDataStore().clear();
+            callback(null, this.getEmptExecutionResponse());
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    startSpecExecution(call, callback) {
+        this._specExecutionStartingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    initializeScenarioDataStore(call, callback) {
+        try {
+            _1.DataStoreFactory.getScenarioDataStore().clear();
+            callback(null, this.getEmptExecutionResponse());
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    startScenarioExecution(call, callback) {
+        this._scenarioExecutionStartingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    startStepExecution(call, callback) {
+        this._stepExecutionStartingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    executeStep(call, callback) {
+        this._executeStepProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    finishStepExecution(call, callback) {
+        this._stepExecutionEndingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    finishScenarioExecution(call, callback) {
+        this._scenarioExecutionEndingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    finishSpecExecution(call, callback) {
+        this._specExecutionEndingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    finishExecution(call, callback) {
+        this._executionEndingProcessor.process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(this.createRpcError(error), null));
+    }
+    cacheFile(call, callback) {
+        try {
+            this._cacheFileRequestProcessor.process(call.request);
+            callback(null, new messages_pb_1.Empty());
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    getStepName(call, callback) {
+        try {
+            callback(null, this._stepNameRequestProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    getGlobPatterns(call, callback) {
+        try {
+            const patterns = Util_1.Util.getImplDirs().map((dir) => {
+                return dir.split(path_1.sep).concat(['**', '*.ts']).join('/');
+            });
+            const res = new messages_pb_1.ImplementationFileGlobPatternResponse();
+            res.setGlobpatternsList(patterns);
+            callback(null, res);
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    getStepNames(call, callback) {
+        try {
+            const res = new messages_pb_1.StepNamesResponse();
+            res.setStepsList(StepRegistry_1.default.getStepTexts());
+            callback(null, res);
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    getStepPositions(call, callback) {
+        try {
+            callback(null, this._stepPositionsRequestProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    getImplementationFiles(call, callback) {
+        try {
+            const res = new messages_pb_1.ImplementationFileListResponse();
+            res.setImplementationfilepathsList(Util_1.Util.getListOfFiles());
+            callback(null, res);
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    implementStub(call, callback) {
+        try {
+            callback(null, this._stubImplementationCodeRequestProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    refactor(call, callback) {
+        try {
+            callback(null, this._refactorRequestProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(this.createRpcError(error), null);
+        }
+    }
+    kill(_call, callback) {
+        callback(null, new messages_pb_1.Empty());
+        setTimeout(() => {
+            this._server && this._server.forceShutdown();
+            process.exit(0);
+        }, 100);
+    }
+    createRpcError(error) {
+        var _a, _b;
+        return { code: constants_1.Status.INTERNAL, message: error.message, stack: (_a = error.stack) !== null && _a !== void 0 ? _a : '', details: `${error.message}${os_1.EOL}${(_b = error.stack) !== null && _b !== void 0 ? _b : ''}` };
+    }
+    getEmptExecutionResponse() {
+        const res = new messages_pb_1.ExecutionStatusResponse();
+        const result = new spec_pb_1.ProtoExecutionResult();
+        result.setFailed(false);
+        res.setExecutionresult(result);
+        return res;
+    }
+}
+exports.RunnerServiceImpl = RunnerServiceImpl;