@eagleoutice/flowr 1.5.2 → 2.0.1

package/cli/repl/server/messages/analysis.d.ts

@@ -0,0 +1,72 @@
+import type { IdMessageBase, MessageDefinition } from './messages';
+import type { ControlFlowInformation } from '../../../../util/cfg/cfg';
+import type { DEFAULT_DATAFLOW_PIPELINE, DEFAULT_SLICING_PIPELINE } from '../../../../core/steps/pipeline/default-pipelines';
+import type { PipelineOutput } from '../../../../core/steps/pipeline/pipeline';
+/**
+ * Send by the client to request an analysis of a given file.
+ * Answered by either an {@link FlowrErrorMessage} or a {@link FileAnalysisResponseMessageJson}.
+ */
+export interface FileAnalysisRequestMessage extends IdMessageBase {
+    type: 'request-file-analysis';
+    /**
+     * This is a unique token that you assign to subsequently slice the respective files.
+     * If you pass the same token multiple times, previous results will be overwritten.
+     *
+     * If you do not pass a file token, the server will _not_ store the results!
+     */
+    filetoken?: string;
+    /**
+     * A human-readable file name. If you present a `filepath` or read from a file this should be straightforward.
+     * However, the name is only for debugging and bears no semantic meaning.
+     */
+    filename?: string;
+    /** The contents of the file, or an R expression itself (like `1 + 1`), give either this or the `filepath`. */
+    content?: string;
+    /** The filepath on the local machine, accessible to flowR, or simply. Give either this or the `content` */
+    filepath?: string;
+    /** Can be used to additionally extract the {@link ControlFlowInformation} of the file, which is not exposed (and not fully calculated) by default. */
+    cfg?: boolean;
+    /** Controls the serialization of the `results` (and the {@link ControlFlowGraph} if the corresponding flag is set). If missing, we assume _json_. */
+    format?: 'json' | 'n-quads';
+}
+export declare const requestAnalysisMessage: MessageDefinition<FileAnalysisRequestMessage>;
+/**
+ * Answer for a successful {@link FileAnalysisRequestMessage}.
+ * It contains the results of the analysis in JSON format (guided by {@link FileAnalysisRequestMessage#format}).
+ *
+ * The `idMap` of the normalization step (see {@link NormalizedAst}) is not serialized as it would essentially
+ * repeat the complete normalized AST.
+ *
+ * @note The serialization of maps and sets is controlled by the {@link jsonReplacer} as part of {@link sendMessage}.
+ *
+ * @see FileAnalysisResponseMessageNQuads
+ */
+export interface FileAnalysisResponseMessageJson extends IdMessageBase {
+    type: 'response-file-analysis';
+    format: 'json';
+    /**
+     * See the {@link SteppingSlicer} and {@link StepResults} for details on the results.
+     */
+    results: PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>;
+    /**
+     * Only if the {@link FileAnalysisRequestMessage} contained a `cfg: true` this will contain the {@link ControlFlowInformation} of the file.
+     */
+    cfg?: ControlFlowInformation;
+}
+/**
+ * Similar to {@link FileAnalysisResponseMessageJson} but using n-quads as serialization format.
+ */
+export interface FileAnalysisResponseMessageNQuads extends IdMessageBase {
+    type: 'response-file-analysis';
+    format: 'n-quads';
+    /**
+     * @see FileAnalysisResponseMessageJson#results
+     */
+    results: {
+        [K in keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>]: string;
+    };
+    /**
+     * @see FileAnalysisResponseMessageJson#cfg
+     */
+    cfg?: string;
+}

package/cli/repl/server/messages/analysis.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestAnalysisMessage = void 0;
+const joi_1 = __importDefault(require("joi"));
+exports.requestAnalysisMessage = {
+    type: 'request-file-analysis',
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('request-file-analysis').required(),
+        id: joi_1.default.string().optional(),
+        filetoken: joi_1.default.string().optional(),
+        filename: joi_1.default.string().optional(),
+        content: joi_1.default.string().optional(),
+        filepath: joi_1.default.string().optional(),
+        cfg: joi_1.default.boolean().optional(),
+        format: joi_1.default.string().valid('json', 'n-quads').optional()
+    }).xor('content', 'filepath')
+};
+//# sourceMappingURL=analysis.js.map

package/cli/repl/server/messages/error.d.ts

@@ -0,0 +1,11 @@
+import type { IdMessageBase } from './messages';
+/**
+ * Sent in case of any error (e.g., if the analysis fails, or the message contains syntax errors).
+ */
+export interface FlowrErrorMessage extends IdMessageBase {
+    type: 'error';
+    /** if fatal, the connection will be partially closed afterward */
+    fatal: boolean;
+    /** the human-readable reason for the error */
+    reason: string;
+}

package/{core/input.js → cli/repl/server/messages/error.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=input.js.map
+//# sourceMappingURL=error.js.map

package/cli/repl/server/messages/hello.d.ts

@@ -0,0 +1,20 @@
+import type { VersionInformation } from '../../commands/version';
+import type { IdMessageBase } from './messages';
+/**
+ * The hello message is automatically send by the sever upon connection.
+ */
+export interface FlowrHelloResponseMessage extends IdMessageBase {
+    type: 'hello';
+    /** The hello message never has an id, it is always undefined */
+    id: undefined;
+    /**
+     * A unique name that is assigned to each client.
+     * It has no semantic meaning and is only used/useful for debugging.
+     */
+    clientName: string;
+    /**
+     * Describes which versions are in use on the server.
+     * @see VersionInformation
+     */
+    versions: VersionInformation;
+}

package/{core/output.js → cli/repl/server/messages/hello.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=output.js.map
+//# sourceMappingURL=hello.js.map

package/cli/repl/server/messages/messages.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Provides the capability of connecting to the repl of flowr via messages.
+ *
+ * @module
+ */
+import * as Joi from 'joi';
+import type { FlowrHelloResponseMessage } from './hello';
+import type { FileAnalysisRequestMessage, FileAnalysisResponseMessageJson } from './analysis';
+import type { ExecuteEndMessage, ExecuteIntermediateResponseMessage, ExecuteRequestMessage } from './repl';
+import type { SliceRequestMessage, SliceResponseMessage } from './slice';
+import type { FlowrErrorMessage } from './error';
+/**
+ * If you send a message it must *not* contain a newline but the message must be terminated by a newline.
+ */
+export interface IdMessageBase {
+    /**
+     * The at this time unknown type
+     */
+    type: string;
+    /**
+     * The id that links a request with its responses, it is up to the calling client to make sure it is unique.
+     * However, the client does not have to pass the id if it does not need to link the request with its response.
+     * The id is always undefined if the message is unprompted (e.g., with hello) or the id unknown.
+     */
+    id: string | undefined;
+}
+export interface MessageDefinition<T extends FlowrMessage | IdMessageBase> {
+    type: T['type'] | undefined;
+    schema: Joi.Schema;
+}
+export declare const baseMessage: MessageDefinition<IdMessageBase>;
+/**
+ * This is the main message type that should be used to represent a message in *flowR*
+ */
+export type FlowrMessage = FlowrHelloResponseMessage | FileAnalysisRequestMessage | FileAnalysisResponseMessageJson | ExecuteRequestMessage | ExecuteIntermediateResponseMessage | ExecuteEndMessage | SliceRequestMessage | SliceResponseMessage | FlowrErrorMessage;

package/cli/repl/server/messages/messages.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseMessage = void 0;
+/**
+ * Provides the capability of connecting to the repl of flowr via messages.
+ *
+ * @module
+ */
+const Joi = __importStar(require("joi"));
+exports.baseMessage = {
+    type: '**base**',
+    schema: Joi.object({
+        type: Joi.string().required(),
+        id: Joi.string().optional()
+    }).unknown(true)
+};
+//# sourceMappingURL=messages.js.map

package/cli/repl/server/messages/repl.d.ts

@@ -0,0 +1,33 @@
+import type { IdMessageBase, MessageDefinition } from './messages';
+/**
+ * Request the execution of the given expression as a REPL statement.
+ * We strongly recommend that you make use of a unique {@link IdMessageBase#id}
+ * in case the message responses happen in parallel.
+ *
+ * @see ExecuteIntermediateResponseMessage
+ * @see ExecuteEndMessage
+ */
+export interface ExecuteRequestMessage extends IdMessageBase {
+    type: 'request-repl-execution';
+    /** Should ansi formatting be enabled for the response? Is `false` by default.  */
+    ansi?: boolean;
+    /** The expression to execute */
+    expression: string;
+}
+export declare const requestExecuteReplExpressionMessage: MessageDefinition<ExecuteRequestMessage>;
+/**
+ * This message may be sent multiple times, triggered for every "output" performed by the execution.
+ * {@link ExecuteEndMessage} marks the end of these messages.
+ */
+export interface ExecuteIntermediateResponseMessage extends IdMessageBase {
+    type: 'response-repl-execution';
+    stream: 'stdout' | 'stderr';
+    result: string;
+}
+/**
+ * Marks the end of the execution of the respective {@link ExecuteRequestMessage}.
+ * The underlying TCP connection should ensure the ordering so that this message is the last.
+ */
+export interface ExecuteEndMessage extends IdMessageBase {
+    type: 'end-repl-execution';
+}

package/cli/repl/server/messages/repl.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestExecuteReplExpressionMessage = void 0;
+const Joi = __importStar(require("joi"));
+exports.requestExecuteReplExpressionMessage = {
+    type: 'request-repl-execution',
+    schema: Joi.object({
+        type: Joi.string().valid('request-repl-execution').required(),
+        id: Joi.string().optional(),
+        ansi: Joi.boolean().optional(),
+        expression: Joi.string().required(),
+    })
+};
+//# sourceMappingURL=repl.js.map

package/cli/repl/server/messages/slice.d.ts

@@ -0,0 +1,26 @@
+import type { IdMessageBase, MessageDefinition } from './messages';
+import type { SlicingCriteria } from '../../../../slicing/criterion/parse';
+import type { PipelineOutput } from '../../../../core/steps/pipeline/pipeline';
+import type { DEFAULT_DATAFLOW_PIPELINE, DEFAULT_SLICING_PIPELINE } from '../../../../core/steps/pipeline/default-pipelines';
+/**
+ * Can only be sent after you have sent the {@link FileAnalysisRequestMessage}.
+ * Using the same `filetoken` as in the {@link FileAnalysisRequestMessage} you
+ * can slice the respective file given the respective criteria.
+ */
+export interface SliceRequestMessage extends IdMessageBase {
+    type: 'request-slice';
+    /** The {@link FileAnalysisRequestMessage#filetoken} of the file/data to slice */
+    filetoken: string;
+    /** The slicing criteria to use */
+    criterion: SlicingCriteria;
+}
+export declare const requestSliceMessage: MessageDefinition<SliceRequestMessage>;
+/**
+ * Similar to {@link FileAnalysisResponseMessage} this only contains the results of
+ * the slice steps.
+ */
+export interface SliceResponseMessage extends IdMessageBase {
+    type: 'response-slice';
+    /** only contains the results of the slice steps to not repeat ourselves */
+    results: Omit<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>, keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>>;
+}

package/cli/repl/server/messages/slice.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestSliceMessage = void 0;
+const Joi = __importStar(require("joi"));
+exports.requestSliceMessage = {
+    type: 'request-slice',
+    schema: Joi.object({
+        type: Joi.string().valid('request-slice').required(),
+        id: Joi.string().optional(),
+        filetoken: Joi.string().required(),
+        criterion: Joi.array().items(Joi.string().regex(/\d+:\d+|\d+@.*|\$\d+/)).min(0).required()
+    })
+};
+//# sourceMappingURL=slice.js.map

package/cli/repl/server/net.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import type WebSocket from 'ws';
+/** Function handler that should be triggered when the respective socket connects */
+export type OnConnect = (c: Socket) => void;
+/**
+ * A generic server interface that allows us to mock the server's behavior in tests.
+ */
+export interface Server {
+    /**
+     * Register a function to be called when a new socket connects.
+     * This should be only called once per server.
+     */
+    onConnect(handler: OnConnect): void;
+    start(port: number): void;
+}
+export declare class WebSocketServerWrapper implements Server {
+    private server;
+    private connectHandler;
+    onConnect(handler: OnConnect): void;
+    start(port: number): void;
+}
+/**
+ * The socket abstraction of *flowR*.
+ * Essentially a subset of what the default `net.Socket` of `node` provides.
+ */
+export interface Socket {
+    remoteAddress?: string;
+    remotePort?: number;
+    on(event: 'error', listener: (e: unknown) => void): void;
+    on(event: 'close', listener: () => void): void;
+    on(event: 'data', listener: (data: Buffer) => void): void;
+    write(data: string): void;
+    end(): void;
+}
+export declare class WebSocketWrapper implements Socket {
+    private readonly socket;
+    remoteAddress?: string;
+    remotePort?: number;
+    constructor(socket: WebSocket);
+    write(data: string): void;
+    end(): void;
+    on(event: 'data' | 'close' | 'error', listener: (data: Buffer) => void): void;
+}
+export declare class NetServer implements Server {
+    private readonly server;
+    constructor();
+    onConnect(handler: OnConnect): void;
+    start(port: number): void;
+}

package/cli/repl/server/net.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetServer = exports.WebSocketWrapper = exports.WebSocketServerWrapper = void 0;
+/**
+ * This is just a simple layer to allow me to mock the server's behavior in tests.
+ */
+const net_1 = __importDefault(require("net"));
+const ws_1 = require("ws");
+const server_1 = require("./server");
+class WebSocketServerWrapper {
+    server;
+    connectHandler;
+    onConnect(handler) {
+        this.connectHandler = handler;
+    }
+    start(port) {
+        this.server = new ws_1.WebSocketServer({ port });
+        server_1.serverLog.info('WebSocket-Server wrapper is active!');
+        this.server.on('connection', c => this.connectHandler?.(new WebSocketWrapper(c)));
+    }
+}
+exports.WebSocketServerWrapper = WebSocketServerWrapper;
+class WebSocketWrapper {
+    socket;
+    remoteAddress;
+    remotePort;
+    constructor(socket) {
+        this.socket = socket;
+        this.remoteAddress = socket.url;
+    }
+    write(data) {
+        this.socket.send(data);
+    }
+    end() {
+        this.socket.close();
+    }
+    on(event, listener) {
+        if (event === 'data') {
+            this.socket.on('message', listener);
+        }
+        else {
+            this.socket.on(event, listener);
+        }
+    }
+}
+exports.WebSocketWrapper = WebSocketWrapper;
+class NetServer {
+    server;
+    constructor() {
+        this.server = net_1.default.createServer();
+    }
+    onConnect(handler) {
+        this.server.on('connection', handler);
+    }
+    start(port) {
+        this.server.listen(port);
+    }
+}
+exports.NetServer = NetServer;
+//# sourceMappingURL=net.js.map

package/cli/repl/server/send.d.ts

@@ -0,0 +1,4 @@
+import type { IdMessageBase } from './messages/messages';
+import type { Socket } from './net';
+export declare function getUnnamedSocketName(c: Socket): string;
+export declare function sendMessage<T extends IdMessageBase>(c: Socket, message: T): void;

package/cli/repl/server/send.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessage = exports.getUnnamedSocketName = void 0;
+const server_1 = require("./server");
+const json_1 = require("../../../util/json");
+function getUnnamedSocketName(c) {
+    return `${c.remoteAddress ?? '?'}@${c.remotePort ?? '?'}`;
+}
+exports.getUnnamedSocketName = getUnnamedSocketName;
+function sendMessage(c, message) {
+    const msg = JSON.stringify(message, json_1.jsonReplacer);
+    if (server_1.serverLog.settings.minLevel >= 2 /* LogLevel.Debug */) {
+        server_1.serverLog.debug(`[${getUnnamedSocketName(c)}] sending message: ${msg}`);
+    }
+    c.write(`${msg}\n`);
+}
+exports.sendMessage = sendMessage;
+//# sourceMappingURL=send.js.map

package/cli/repl/server/server.d.ts

@@ -0,0 +1,20 @@
+import type { Server } from './net';
+import { FlowrLogger } from '../../../util/log';
+import type { RShell } from '../../../r-bridge/shell';
+export declare const serverLog: FlowrLogger;
+/**
+ * This class controls the TCP server, which can be started by calling {@link start}.
+ * Afterward, each incoming connection will be greeted with {@link helloClient} and from
+ * thereon be handled by a {@link FlowRServerConnection}.
+ */
+export declare class FlowRServer {
+    private readonly server;
+    private readonly shell;
+    private versionInformation;
+    /** maps names to the respective connection */
+    private connections;
+    private nameCounter;
+    constructor(shell: RShell, server?: Server);
+    start(port: number): Promise<void>;
+    private onConnect;
+}

package/cli/repl/server/server.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowRServer = exports.serverLog = void 0;
+const version_1 = require("../commands/version");
+const connection_1 = require("./connection");
+const send_1 = require("./send");
+const net_1 = require("./net");
+const log_1 = require("../../../util/log");
+// we detach from the main logger so that it can have its own switch
+exports.serverLog = new log_1.FlowrLogger({ name: 'server' });
+/**
+ * This class controls the TCP server, which can be started by calling {@link start}.
+ * Afterward, each incoming connection will be greeted with {@link helloClient} and from
+ * thereon be handled by a {@link FlowRServerConnection}.
+ */
+class FlowRServer {
+    server;
+    shell;
+    versionInformation;
+    /** maps names to the respective connection */
+    connections = new Map();
+    nameCounter = 0;
+    constructor(shell, server = new net_1.NetServer()) {
+        this.server = server;
+        this.server.onConnect(c => this.onConnect(c));
+        this.shell = shell;
+    }
+    async start(port) {
+        this.versionInformation = await (0, version_1.retrieveVersionInformation)(this.shell);
+        this.server.start(port);
+        exports.serverLog.info(`Server listening on port ${port}`);
+    }
+    onConnect(c) {
+        if (!this.versionInformation) {
+            notYetInitialized(c, undefined);
+            return;
+        }
+        const name = `client-${this.nameCounter++}`;
+        exports.serverLog.info(`Client connected: ${(0, send_1.getUnnamedSocketName)(c)} as "${name}"`);
+        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.shell));
+        helloClient(c, name, this.versionInformation);
+        c.on('close', () => {
+            this.connections.delete(name);
+            exports.serverLog.info(`Client "${name}" disconnected (${(0, send_1.getUnnamedSocketName)(c)})`);
+        });
+    }
+}
+exports.FlowRServer = FlowRServer;
+function notYetInitialized(c, id) {
+    (0, send_1.sendMessage)(c, {
+        id,
+        type: 'error',
+        fatal: true,
+        reason: 'Server not initialized yet (or failed to), please try again later.'
+    });
+    c.end();
+}
+function helloClient(c, name, versionInformation) {
+    (0, send_1.sendMessage)(c, {
+        id: undefined,
+        type: 'hello',
+        clientName: name,
+        versions: versionInformation
+    });
+}
+//# sourceMappingURL=server.js.map

package/cli/repl/server/validate.d.ts

@@ -0,0 +1,15 @@
+import type * as Joi from 'joi';
+import type { FlowrMessage, IdMessageBase, MessageDefinition } from './messages/messages';
+import type { Socket } from './net';
+export interface ValidationErrorResult {
+    type: 'error';
+    reason: Joi.ValidationError | Error;
+}
+export interface SuccessValidationResult<T extends IdMessageBase> {
+    type: 'success';
+    message: T;
+}
+export type ValidationResult<T extends IdMessageBase> = SuccessValidationResult<T> | ValidationErrorResult;
+export declare function validateBaseMessageFormat(input: string): ValidationResult<IdMessageBase>;
+export declare function validateMessage<T extends FlowrMessage | IdMessageBase>(input: IdMessageBase, def: MessageDefinition<T>): ValidationResult<T>;
+export declare function answerForValidationError(client: Socket, result: ValidationErrorResult, id?: string): void;

package/cli/repl/server/validate.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.answerForValidationError = exports.validateMessage = exports.validateBaseMessageFormat = void 0;
+const send_1 = require("./send");
+const messages_1 = require("./messages/messages");
+function validateBaseMessageFormat(input) {
+    try {
+        return validateMessage(JSON.parse(input), messages_1.baseMessage);
+    }
+    catch (e) {
+        return { type: 'error', reason: e };
+    }
+}
+exports.validateBaseMessageFormat = validateBaseMessageFormat;
+function validateMessage(input, def) {
+    try {
+        const result = def.schema.validate(input);
+        return result.error ? { type: 'error', reason: result.error } : { type: 'success', message: input };
+    }
+    catch (e) {
+        return { type: 'error', reason: e };
+    }
+}
+exports.validateMessage = validateMessage;
+function answerForValidationError(client, result, id) {
+    (0, send_1.sendMessage)(client, {
+        type: 'error',
+        fatal: false,
+        id: id,
+        reason: `Invalid message format: ${result.reason.message}`
+    });
+}
+exports.answerForValidationError = answerForValidationError;
+//# sourceMappingURL=validate.js.map

package/cli/slicer-app.d.ts

@@ -0,0 +1,11 @@
+export interface SlicerCliOptions {
+    verbose: boolean;
+    help: boolean;
+    input: string | undefined;
+    criterion: string | undefined;
+    output: string | undefined;
+    diff: boolean;
+    'input-is-text': boolean;
+    stats: boolean;
+    api: boolean;
+}