gauge-ts 0.1.1 → 0.3.1

package/dist/RunnerServer.d.ts

@@ -0,0 +1,50 @@
+import { Server } from "@grpc/grpc-js";
+import type { ServerUnaryCall as SUC, sendUnaryData as sUD } from "@grpc/grpc-js";
+import { Empty, ImplementationFileGlobPatternResponse as IFGPR, ImplementationFileListResponse as IFLR, StepNamesResponse } from "./gen/messages_pb";
+import type { CacheFileRequest, ExecutionStatusResponse as ESR, ExecuteStepRequest, ExecutionEndingRequest, ExecutionStartingRequest, FileDiff, 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, StepPositionsRequest, StepPositionsResponse, StepValidateRequest, StepValidateResponse, StubImplementationCodeRequest, SuiteDataStoreInitRequest } from "./gen/messages_pb";
+import type { IRunnerServer } from "./gen/services_grpc_pb";
+import StaticLoader from "./loaders/StaticLoader";
+export default class RunnerServer implements IRunnerServer {
+    [name: string]: import("@grpc/grpc-js").UntypedHandleCall;
+    private static cacheFileProcessor;
+    private static executionEndingProcessor;
+    private static executionStartingProcessor;
+    private static refactorProcessor;
+    private static scenarioExecutionEndingProcessor;
+    private static scenarioExecutionStartingProcessor;
+    private static specExecutionEndingProcessor;
+    private static specExecutionStartingProcessor;
+    private static stepExecutionEndingProcessor;
+    private static stepExecutionProcessor;
+    private static stepExecutionStartingProcessor;
+    private static stepNameProcessor;
+    private static stepPositionsProcessor;
+    private static stubImplementationCodeProcessor;
+    private static validationProcessor;
+    constructor(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 getEmptExecutionResponse;
+}
+export declare const start: (host?: string, server?: Server, runnerService?: RunnerServer) => void;
+export declare const stop: (server?: Server | null) => void;

package/dist/RunnerServer.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stop = exports.start = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const grpc_js_1 = require("@grpc/grpc-js");
+const services_grpc_pb_1 = require("./gen/services_grpc_pb");
+const constants_1 = require("@grpc/grpc-js/build/src/constants");
+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 StaticLoader_1 = require("./loaders/StaticLoader");
+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 RunnerServer {
+    static cacheFileProcessor;
+    static executionEndingProcessor;
+    static executionStartingProcessor;
+    static refactorProcessor;
+    static scenarioExecutionEndingProcessor;
+    static scenarioExecutionStartingProcessor;
+    static specExecutionEndingProcessor;
+    static specExecutionStartingProcessor;
+    static stepExecutionEndingProcessor;
+    static stepExecutionProcessor;
+    static stepExecutionStartingProcessor;
+    static stepNameProcessor;
+    static stepPositionsProcessor;
+    static stubImplementationCodeProcessor;
+    static validationProcessor;
+    constructor(loader) {
+        loader.loadImplementations();
+        RunnerServer.cacheFileProcessor = new CacheFileProcessor_1.CacheFileProcessor(loader);
+        RunnerServer.executionEndingProcessor = new ExecutionEndingProcessor_1.ExecutionEndingProcessor();
+        RunnerServer.executionStartingProcessor = new ExecutionStartingProcessor_1.ExecutionStartingProcessor();
+        RunnerServer.refactorProcessor = new RefactorProcessor_1.RefactorProcessor();
+        RunnerServer.scenarioExecutionEndingProcessor =
+            new ScenarioExecutionEndingProcessor_1.ScenarioExecutionEndingProcessor();
+        RunnerServer.scenarioExecutionStartingProcessor =
+            new ScenarioExecutionStartingProcessor_1.ScenarioExecutionStartingProcessor();
+        RunnerServer.specExecutionEndingProcessor =
+            new SpecExecutionEndingProcessor_1.SpecExecutionEndingProcessor();
+        RunnerServer.specExecutionStartingProcessor =
+            new SpecExecutionStartingProcessor_1.SpecExecutionStartingProcessor();
+        RunnerServer.stepExecutionEndingProcessor =
+            new StepExecutionEndingProcessor_1.StepExecutionEndingProcessor();
+        RunnerServer.stepExecutionProcessor = new StepExecutionProcessor_1.StepExecutionProcessor();
+        RunnerServer.stepExecutionStartingProcessor =
+            new StepExecutionStartingProcessor_1.StepExecutionStartingProcessor();
+        RunnerServer.stepNameProcessor = new StepNameProcessor_1.StepNameProcessor();
+        RunnerServer.stepPositionsProcessor = new StepPositionsProcessor_1.StepPositionsProcessor();
+        RunnerServer.stubImplementationCodeProcessor =
+            new StubImplementationCodeProcessor_1.StubImplementationCodeProcessor();
+        RunnerServer.validationProcessor = new ValidationProcessor_1.ValidationProcessor();
+    }
+    validateStep(call, callback) {
+        try {
+            callback(null, RunnerServer.validationProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(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(createRpcError(err), null);
+            });
+        }
+        catch (error) {
+            callback(createRpcError(error), null);
+        }
+    }
+    startExecution(call, callback) {
+        RunnerServer.executionStartingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    initializeSpecDataStore(call, callback) {
+        try {
+            _1.DataStoreFactory.getSpecDataStore().clear();
+            callback(null, this.getEmptExecutionResponse());
+        }
+        catch (error) {
+            callback(createRpcError(error), null);
+        }
+    }
+    startSpecExecution(call, callback) {
+        RunnerServer.specExecutionStartingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    initializeScenarioDataStore(call, callback) {
+        try {
+            _1.DataStoreFactory.getScenarioDataStore().clear();
+            callback(null, this.getEmptExecutionResponse());
+        }
+        catch (error) {
+            callback(createRpcError(error), null);
+        }
+    }
+    startScenarioExecution(call, callback) {
+        RunnerServer.scenarioExecutionStartingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    startStepExecution(call, callback) {
+        RunnerServer.stepExecutionStartingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    executeStep(call, callback) {
+        RunnerServer.stepExecutionProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    finishStepExecution(call, callback) {
+        RunnerServer.stepExecutionEndingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    finishScenarioExecution(call, callback) {
+        RunnerServer.scenarioExecutionEndingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    finishSpecExecution(call, callback) {
+        RunnerServer.specExecutionEndingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    finishExecution(call, callback) {
+        RunnerServer.executionEndingProcessor
+            .process(call.request)
+            .then((res) => callback(null, res))
+            .catch((error) => callback(createRpcError(error), null));
+    }
+    cacheFile(call, callback) {
+        try {
+            RunnerServer.cacheFileProcessor.process(call.request);
+            callback(null, new messages_pb_1.Empty());
+        }
+        catch (error) {
+            callback(createRpcError(error), null);
+        }
+    }
+    getStepName(call, callback) {
+        try {
+            callback(null, RunnerServer.stepNameProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(createRpcError(error), null);
+        }
+    }
+    getGlobPatterns(call, callback) {
+        try {
+            const patterns = Util_1.Util.getImplDirs().map((dir) => {
+                return dir.split(node_path_1.sep).concat(["**", "*.ts"]).join("/");
+            });
+            const res = new messages_pb_1.ImplementationFileGlobPatternResponse();
+            res.setGlobpatternsList(patterns);
+            callback(null, res);
+        }
+        catch (error) {
+            callback(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(createRpcError(error), null);
+        }
+    }
+    getStepPositions(call, callback) {
+        try {
+            callback(null, RunnerServer.stepPositionsProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(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(createRpcError(error), null);
+        }
+    }
+    implementStub(call, callback) {
+        try {
+            callback(null, RunnerServer.stubImplementationCodeProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(createRpcError(error), null);
+        }
+    }
+    refactor(call, callback) {
+        try {
+            callback(null, RunnerServer.refactorProcessor.process(call.request));
+        }
+        catch (error) {
+            callback(createRpcError(error), null);
+        }
+    }
+    kill(_call, callback) {
+        callback(null, new messages_pb_1.Empty());
+        setTimeout(() => {
+            (0, exports.stop)();
+            process.exit(0);
+        }, 100);
+    }
+    getEmptExecutionResponse() {
+        const res = new messages_pb_1.ExecutionStatusResponse();
+        const result = new spec_pb_1.ProtoExecutionResult();
+        result.setFailed(false);
+        res.setExecutionresult(result);
+        return res;
+        // eslint-disable-next-line padded-blocks
+    }
+}
+exports.default = RunnerServer;
+function createRpcError(error) {
+    return {
+        code: constants_1.Status.INTERNAL,
+        message: error.message,
+        stack: error.stack ?? "",
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        details: `${error.message}${node_os_1.EOL}${error.stack ?? ""}`,
+    };
+}
+let serverInstance = null;
+const start = (host = "127.0.0.1:0", server = new grpc_js_1.Server(), runnerService = new RunnerServer(new StaticLoader_1.default())) => {
+    serverInstance = server;
+    server.addService(services_grpc_pb_1.RunnerService, runnerService);
+    let port = null;
+    server.bindAsync(host, grpc_js_1.ServerCredentials.createInsecure(), (err, boundPort) => {
+        if (err) {
+            throw err;
+        }
+        port = boundPort;
+        console.debug(`Listening on port:${port}`);
+    });
+};
+exports.start = start;
+const stop = (server = serverInstance) => {
+    if (!serverInstance) {
+        console.debug("Server is not running.");
+        return;
+    }
+    server?.tryShutdown((err) => {
+        if (err) {
+            console.error("Error shutting down the server:", err);
+        }
+        else {
+            serverInstance = null;
+        }
+    });
+};
+exports.stop = stop;