@trayio/cdk-runtime 3.8.0 → 3.9.0

package/dist/connector/operation/CompositeOperationExecution.js

@@ -1,38 +1,29 @@
 "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 });
 exports.CompositeOperationExecution = void 0;
 const OperationHandler_1 = require("@trayio/cdk-dsl/connector/operation/OperationHandler");
 class CompositeOperationExecution {
+    handlerInvocationFactory;
+    handler;
     constructor(handlerInvocationFactory, handler) {
         this.handlerInvocationFactory = handlerInvocationFactory;
         this.handler = handler;
     }
-    execute(ctx, input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handlerInvocation = this.handlerInvocationFactory(ctx);
-            try {
-                const result = yield this.handler.handlerFunction(ctx, input, handlerInvocation);
-                return result;
+    async execute(ctx, input) {
+        const handlerInvocation = this.handlerInvocationFactory(ctx);
+        try {
+            const result = await this.handler.handlerFunction(ctx, input, handlerInvocation);
+            return result;
+        }
+        catch (error) {
+            if (this.isError(error)) {
+                return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(error.message));
             }
-            catch (error) {
-                if (this.isError(error)) {
-                    return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(error.message));
-                }
-                if (typeof error === 'string') {
-                    return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(error));
-                }
-                return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError('Operation failed with unknown error'));
+            if (typeof error === 'string') {
+                return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(error));
             }
-        });
+            return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError('Operation failed with unknown error'));
+        }
     }
     // TODO: Move to commons
     isError(error) {

package/dist/connector/operation/CompositeOperationExecutionFactory.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompositeOperationExecutionFactory = void 0;
 const CompositeOperationExecution_1 = require("./CompositeOperationExecution");
 class CompositeOperationExecutionFactory {
+    handlerInvocationFactory;
     constructor(handlerInvocationFactory) {
         this.handlerInvocationFactory = handlerInvocationFactory;
     }

package/dist/connector/operation/HttpOperationExecution.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 });
 exports.HttpOperationExecution = void 0;
 const TE = __importStar(require("fp-ts/TaskEither"));
@@ -48,6 +39,11 @@ const BufferExtensions_1 = require("@trayio/commons/buffer/BufferExtensions");
 const mime = require('mime');
 const { AWS_LAMBDA_FUNCTION_MEMORY_SIZE, CONNECTOR_MAX_ALLOCATED_RAM_MB } = process.env;
 class HttpOperationExecution {
+    jsonSerialization;
+    httpClient;
+    handler;
+    fileStorage;
+    globalConfiguration;
     constructor(httpClient, fileStorage, handler, globalConfiguration) {
         this.jsonSerialization = new JsonSerialization_1.JsonSerialization();
         this.httpClient = httpClient;
@@ -55,24 +51,22 @@ class HttpOperationExecution {
         this.handler = handler;
         this.globalConfiguration = globalConfiguration;
     }
-    execute(ctx, input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const request = (0, function_1.pipe)(this.globalConfiguration, O.match(() => this.handler.request, (globalConfig) => this.decorateRequest(globalConfig, this.handler.request, ctx)));
-            const operationRequest = this.handler.requestHandler(ctx, input, request);
-            const httpRequestE = yield this.operationRequestToHttpRequest(operationRequest)();
-            if (E.isLeft(httpRequestE)) {
-                return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(httpRequestE.left.message));
-            }
-            const resultTE = this.httpClient.execute(operationRequest.method, operationRequest.path, httpRequestE.right);
-            const operationResponseTE = (0, function_1.pipe)(resultTE, 
-            // get the dsl http response object
-            TE.map((response) => this.handler.responseHandler(ctx, input, new HttpOperationHandler_1.HttpOperationResponseBuilder(response, this.defaultErrorHandling(response.statusCode)))), 
-            // interpret the dsl response object by mapping the low level http response to a connector response
-            TE.chain((operationResponse) => this.parseResponse(operationResponse)), 
-            // handle errors during the execution of the http request or parsing or the http response
-            TE.mapLeft((error) => OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(error.message))));
-            return TE.toUnion(operationResponseTE)();
-        });
+    async execute(ctx, input) {
+        const request = (0, function_1.pipe)(this.globalConfiguration, O.match(() => this.handler.request, (globalConfig) => this.decorateRequest(globalConfig, this.handler.request, ctx)));
+        const operationRequest = this.handler.requestHandler(ctx, input, request);
+        const httpRequestE = await this.operationRequestToHttpRequest(operationRequest)();
+        if (E.isLeft(httpRequestE)) {
+            return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(httpRequestE.left.message));
+        }
+        const resultTE = this.httpClient.execute(operationRequest.method, operationRequest.path, httpRequestE.right);
+        const operationResponseTE = (0, function_1.pipe)(resultTE, 
+        // get the dsl http response object
+        TE.map((response) => this.handler.responseHandler(ctx, input, new HttpOperationHandler_1.HttpOperationResponseBuilder(response, this.defaultErrorHandling(response.statusCode)))), 
+        // interpret the dsl response object by mapping the low level http response to a connector response
+        TE.chain((operationResponse) => this.parseResponse(operationResponse)), 
+        // handle errors during the execution of the http request or parsing or the http response
+        TE.mapLeft((error) => OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(error.message))));
+        return TE.toUnion(operationResponseTE)();
     }
     decorateRequest(globalConfig, operationRequest, ctx) {
         return (0, function_1.pipe)(globalConfig.baseUrl, O.fold(() => operationRequest, (baseUrl) => operationRequest.withUrl(`${baseUrl(ctx)}${operationRequest.path}`)), (request) => (0, function_1.pipe)(globalConfig.bearerToken, O.fold(() => request, (bearerToken) => request.withBearerToken(bearerToken(ctx)))), (request) => (0, function_1.pipe)(globalConfig.headers, (headers) => {
@@ -101,7 +95,10 @@ class HttpOperationExecution {
                 default:
                     return this.serializeAsJson(operationRequest.body);
             }
-        }), O.getOrElse(() => this.serializeEmptyBody()), TE.map((serializedBody) => (Object.assign(Object.assign({}, operationRequest.request), { body: serializedBody }))));
+        }), O.getOrElse(() => this.serializeEmptyBody()), TE.map((serializedBody) => ({
+            ...operationRequest.request,
+            body: serializedBody,
+        })));
     }
     serializeAsJson(body) {
         const serializedBody = this.jsonSerialization.serialize(body);
@@ -210,18 +207,15 @@ class HttpOperationExecution {
             key: fileExtension ? `${(0, uuid_1.v4)()}.${fileExtension}` : (0, uuid_1.v4)(),
             metadata: {
                 name: (0, uuid_1.v4)(),
-                size: parseFloat(contentLength !== null && contentLength !== void 0 ? contentLength : undefined),
+                size: parseFloat(contentLength ?? undefined),
                 contentType,
             },
-        }, O.some(uploadOptions)), TE.chain((file) => (0, function_1.pipe)(this.fileStorage.getSharedUrl(file.key), TE.map((sharedUrl) => {
-            var _a, _b;
-            return operationResponse.responseParser({
-                name: file.metadata.name,
-                url: sharedUrl.url,
-                mime_type: (_a = file.metadata.contentType) !== null && _a !== void 0 ? _a : '',
-                expires: (_b = sharedUrl.expires) !== null && _b !== void 0 ? _b : 0,
-            });
-        }))));
+        }, O.some(uploadOptions)), TE.chain((file) => (0, function_1.pipe)(this.fileStorage.getSharedUrl(file.key), TE.map((sharedUrl) => operationResponse.responseParser({
+            name: file.metadata.name,
+            url: sharedUrl.url,
+            mime_type: file.metadata.contentType ?? '',
+            expires: sharedUrl.expires ?? 0,
+        })))));
     }
     parseBodyAsText(operationResponse) {
         const arrayBufferTE = BufferExtensions_1.BufferExtensions.readableToArrayBuffer(operationResponse.response.body);

package/dist/connector/operation/HttpOperationExecutionFactory.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpOperationExecutionFactory = void 0;
 const HttpOperationExecution_1 = require("./HttpOperationExecution");
 class HttpOperationExecutionFactory {
+    httpClient;
+    fileStorage;
     constructor(httpClient, fileStorage) {
         this.httpClient = httpClient;
         this.fileStorage = fileStorage;

package/dist/connector/operation/OperationExecutionFactory.js

@@ -5,6 +5,9 @@ const HttpOperationExecutionFactory_1 = require("./HttpOperationExecutionFactory
 const CompositeOperationExecutionFactory_1 = require("./CompositeOperationExecutionFactory");
 const OperationExecutionValidationFactory_1 = require("./OperationExecutionValidationFactory");
 class OperationExecutionFactory {
+    operationExecutionValidationFactory;
+    httpOperationExecutionFactory;
+    compositeOperationExecutionFactory;
     constructor(httpClient, fileStorage, operationHandlerInvocationFactory) {
         this.operationExecutionValidationFactory =
             new OperationExecutionValidationFactory_1.OperationExecutionValidationFactory();

package/dist/connector/operation/OperationExecutionGateway.js

@@ -30,6 +30,8 @@ const OperationHandler_1 = require("@trayio/cdk-dsl/connector/operation/Operatio
 const OperationHandlerSetup_1 = require("@trayio/cdk-dsl/connector/operation/OperationHandlerSetup");
 const OperationExecutionFactory_1 = require("./OperationExecutionFactory");
 class OperationExecutionGateway {
+    executionFactory;
+    operationHandlerInvocationFactory;
     constructor(httpClient, fileStorage) {
         const operationHandlerInvocationFactory = (ctx) => (handlerReference) => (input) => {
             const result = (0, function_1.pipe)(this.lookup(handlerReference, true), O.map((handlerExecution) => handlerExecution.execute(ctx, input)));

package/dist/connector/operation/OperationExecutionGateway.unit.test.js

@@ -39,100 +39,98 @@ require("./OperationHandlerTestRunner");
 const OperationGlobalConfig_1 = require("@trayio/cdk-dsl/connector/operation/OperationGlobalConfig");
 const fileStorage = new NodeFsFileStorage_1.NodeFsFileStorage('/tmp');
 class TestControllerHttp {
-    constructor() {
-        this.getEndpoints = () => [
-            {
-                path: `/posts/:id`,
-                method: Http_1.HttpMethod.Get,
-                execute: (request) => {
-                    const { id } = request.pathParams;
+    getEndpoints = () => [
+        {
+            path: `/posts/:id`,
+            method: Http_1.HttpMethod.Get,
+            execute: (request) => {
+                const { id } = request.pathParams;
+                return T.of({
+                    body: stream_1.Readable.from(JSON.stringify({
+                        id: parseInt(id, 10),
+                        title: 'test',
+                    })),
+                    headers: {},
+                    statusCode: 200,
+                });
+            },
+        },
+        {
+            path: `/tokens`,
+            method: Http_1.HttpMethod.Get,
+            execute: (request) => {
+                const token = request.headers.authorization;
+                if (token === 'Bearer valid') {
                     return T.of({
                         body: stream_1.Readable.from(JSON.stringify({
-                            id: parseInt(id, 10),
-                            title: 'test',
+                            success: true,
                         })),
                         headers: {},
                         statusCode: 200,
                     });
-                },
+                }
+                throw new Error('Unauthorized');
             },
-            {
-                path: `/tokens`,
-                method: Http_1.HttpMethod.Get,
-                execute: (request) => {
-                    const token = request.headers.authorization;
-                    if (token === 'Bearer valid') {
-                        return T.of({
-                            body: stream_1.Readable.from(JSON.stringify({
-                                success: true,
-                            })),
-                            headers: {},
-                            statusCode: 200,
-                        });
-                    }
-                    throw new Error('Unauthorized');
-                },
-            },
-            {
-                path: `/posts/create`,
-                method: Http_1.HttpMethod.Post,
-                execute: (request) => {
-                    const { body } = request;
-                    return T.of({
-                        body: body,
-                        headers: {},
-                        statusCode: 200,
-                    });
-                },
+        },
+        {
+            path: `/posts/create`,
+            method: Http_1.HttpMethod.Post,
+            execute: (request) => {
+                const { body } = request;
+                return T.of({
+                    body: body,
+                    headers: {},
+                    statusCode: 200,
+                });
             },
-            {
-                path: `/image-upload`,
-                method: Http_1.HttpMethod.Post,
-                execute: (request) => {
-                    const { body } = request;
-                    return (0, function_1.pipe)(fileStorage.write({
-                        content: body,
-                        key: 'test.ico',
-                        metadata: {
-                            name: 'test.ico',
-                        },
-                    }), TE.fold(() => T.of({
-                        body: stream_1.Readable.from(JSON.stringify({
-                            success: false,
-                        })),
-                        headers: {},
-                        statusCode: 500,
-                    }), () => T.of({
-                        body: stream_1.Readable.from(JSON.stringify({
-                            success: true,
-                        })),
-                        headers: {},
-                        statusCode: 200,
-                    })));
-                },
+        },
+        {
+            path: `/image-upload`,
+            method: Http_1.HttpMethod.Post,
+            execute: (request) => {
+                const { body } = request;
+                return (0, function_1.pipe)(fileStorage.write({
+                    content: body,
+                    key: 'test.ico',
+                    metadata: {
+                        name: 'test.ico',
+                    },
+                }), TE.fold(() => T.of({
+                    body: stream_1.Readable.from(JSON.stringify({
+                        success: false,
+                    })),
+                    headers: {},
+                    statusCode: 500,
+                }), () => T.of({
+                    body: stream_1.Readable.from(JSON.stringify({
+                        success: true,
+                    })),
+                    headers: {},
+                    statusCode: 200,
+                })));
             },
-            {
-                path: `/multipart-upload`,
-                method: Http_1.HttpMethod.Post,
-                execute: (request) => {
-                    const { body } = request;
-                    expect(body).toEqual(expect.objectContaining({
-                        fields: expect.objectContaining({ test: 'Hello world!' }),
-                        files: expect.objectContaining({
-                            'test-image': expect.any(Object),
-                        }),
-                    }));
-                    return T.of({
-                        body: stream_1.Readable.from(JSON.stringify({
-                            success: true,
-                        })),
-                        headers: {},
-                        statusCode: 200,
-                    });
-                },
+        },
+        {
+            path: `/multipart-upload`,
+            method: Http_1.HttpMethod.Post,
+            execute: (request) => {
+                const { body } = request;
+                expect(body).toEqual(expect.objectContaining({
+                    fields: expect.objectContaining({ test: 'Hello world!' }),
+                    files: expect.objectContaining({
+                        'test-image': expect.any(Object),
+                    }),
+                }));
+                return T.of({
+                    body: stream_1.Readable.from(JSON.stringify({
+                        success: true,
+                    })),
+                    headers: {},
+                    statusCode: 200,
+                });
             },
-        ];
-    }
+        },
+    ];
 }
 const testHttpController = new ExpressHttpController_1.ExpressHttpController(new TestControllerHttp(), '/tmp');
 describe('OperationExecutionGateway', () => {

package/dist/connector/operation/OperationExecutionTest.js

@@ -1,13 +1,4 @@
 "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 });
 exports.OperationExecutionTest = void 0;
 const WinstonCliLogging_1 = require("@trayio/winston/cli/WinstonCliLogging");
@@ -18,6 +9,8 @@ function fail(reason) {
 }
 global.fail = fail;
 class OperationExecutionTest {
+    handlerTest;
+    handlerInvocationFactory;
     constructor(handlerTest, handlerInvocationFactory) {
         this.handlerTest = handlerTest;
         this.handlerInvocationFactory = handlerInvocationFactory;
@@ -27,21 +20,21 @@ class OperationExecutionTest {
             const defaultCtx = this.handlerTest.ctx;
             const defaultInvoke = this.handlerInvocationFactory(defaultCtx);
             let testContext;
-            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
-                const beforeAllResult = yield this.handlerTest.beforeAllFunction(defaultCtx, defaultInvoke);
+            beforeAll(async () => {
+                const beforeAllResult = await this.handlerTest.beforeAllFunction(defaultCtx, defaultInvoke);
                 switch (beforeAllResult.isSuccess) {
                     case false:
                         fail(`BeforeAll has failed with the following error ${beforeAllResult.error}`);
                     case true:
                         testContext = beforeAllResult.value;
                 }
-            }));
+            });
             this.handlerTest.testCaseFactories.forEach((testCaseFactory) => {
-                it(testCaseFactory.description, () => __awaiter(this, void 0, void 0, function* () {
+                it(testCaseFactory.description, async () => {
                     const testCase = testCaseFactory.testCase(testContext);
                     const { ctx } = testCase;
                     const invoke = this.handlerInvocationFactory(ctx);
-                    const givenResult = yield testCase.givenFunction(ctx, testContext, invoke);
+                    const givenResult = await testCase.givenFunction(ctx, testContext, invoke);
                     let testCaseContext;
                     switch (givenResult.isSuccess) {
                         case false:
@@ -50,7 +43,7 @@ class OperationExecutionTest {
                             testCaseContext = givenResult.value;
                     }
                     const input = testCase.whenFunction(ctx, testContext, testCaseContext);
-                    const output = yield execution.execute(ctx, input);
+                    const output = await execution.execute(ctx, input);
                     const infoArg = process.argv.filter((arg) => arg.startsWith('--verbose'))[0];
                     if (infoArg === '--verbose=true') {
                         const logger = new WinstonCliLogging_1.WinstonCliLogging();
@@ -70,18 +63,18 @@ class OperationExecutionTest {
                         output,
                     };
                     testCase.thenFunction(testCaseResult);
-                    const finallyResult = yield testCase.finallyFunction(testCaseResult, invoke);
+                    const finallyResult = await testCase.finallyFunction(testCaseResult, invoke);
                     if (finallyResult.isFailure) {
                         fail(`Finally has failed with the following error ${finallyResult.error}`);
                     }
-                }));
+                });
             });
-            afterAll(() => __awaiter(this, void 0, void 0, function* () {
-                const afterAllResult = yield this.handlerTest.afterAllFunction(defaultCtx, testContext, defaultInvoke);
+            afterAll(async () => {
+                const afterAllResult = await this.handlerTest.afterAllFunction(defaultCtx, testContext, defaultInvoke);
                 if (afterAllResult.isFailure) {
                     fail(`AfterAll has failed with the following error ${afterAllResult.error}`);
                 }
-            }));
+            });
         });
     }
 }

package/dist/connector/operation/OperationExecutionTestRunner.js

@@ -30,6 +30,7 @@ const E = __importStar(require("fp-ts/Either"));
 const function_1 = require("fp-ts/function");
 const OperationExecutionTest_1 = require("./OperationExecutionTest");
 class OperationExecutionTestRunner {
+    operationExecutionGateway;
     constructor(operationExecutionGateway) {
         this.operationExecutionGateway = operationExecutionGateway;
     }

package/dist/connector/operation/OperationExecutionValidation.js

@@ -1,47 +1,38 @@
 "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 });
 exports.OperationExecutionValidation = void 0;
 const OperationHandler_1 = require("@trayio/cdk-dsl/connector/operation/OperationHandler");
 class OperationExecutionValidation {
+    handlerValidation;
+    execution;
     constructor(handlerValidation, execution) {
         this.handlerValidation = handlerValidation;
         this.execution = execution;
     }
-    execute(ctx, input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO Add input schema validation
-            const { inputValidation } = this.handlerValidation;
-            const inputValidationResult = inputValidation
-                .filter((validation) => !validation.condition(ctx, input))
-                .map((validation) => validation.errorMessage(ctx, input));
-            if (inputValidationResult.length > 0) {
-                return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.userInputError(inputValidationResult.join(', ')));
-            }
-            const result = yield this.execution.execute(ctx, input);
-            switch (result.isFailure) {
-                case true:
-                    return result;
-                case false:
-                    // TODO Add output schema validation
-                    const { outputValidation } = this.handlerValidation;
-                    const outputValidationResult = outputValidation
-                        .filter((validation) => !validation.condition(ctx, input, result.value))
-                        .map((validation) => validation.errorMessage(ctx, input, result.value));
-                    if (outputValidationResult.length > 0) {
-                        return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(outputValidationResult.join(', ')));
-                    }
-                    return result;
-            }
-        });
+    async execute(ctx, input) {
+        // TODO Add input schema validation
+        const { inputValidation } = this.handlerValidation;
+        const inputValidationResult = inputValidation
+            .filter((validation) => !validation.condition(ctx, input))
+            .map((validation) => validation.errorMessage(ctx, input));
+        if (inputValidationResult.length > 0) {
+            return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.userInputError(inputValidationResult.join(', ')));
+        }
+        const result = await this.execution.execute(ctx, input);
+        switch (result.isFailure) {
+            case true:
+                return result;
+            case false:
+                // TODO Add output schema validation
+                const { outputValidation } = this.handlerValidation;
+                const outputValidationResult = outputValidation
+                    .filter((validation) => !validation.condition(ctx, input, result.value))
+                    .map((validation) => validation.errorMessage(ctx, input, result.value));
+                if (outputValidationResult.length > 0) {
+                    return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(outputValidationResult.join(', ')));
+                }
+                return result;
+        }
     }
 }
 exports.OperationExecutionValidation = OperationExecutionValidation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/cdk-runtime",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "description": "A Runtime that executes connector operations defined using the CDK DSL",
   "exports": {
     "./*": "./dist/*.js"
@@ -14,10 +14,10 @@
     "node": ">=18.x"
   },
   "dependencies": {
-    "@trayio/axios": "3.8.0",
-    "@trayio/cdk-dsl": "3.8.0",
-    "@trayio/express": "3.8.0",
-    "@trayio/winston": "3.8.0",
+    "@trayio/axios": "3.9.0",
+    "@trayio/cdk-dsl": "3.9.0",
+    "@trayio/express": "3.9.0",
+    "@trayio/winston": "3.9.0",
     "mime": "3.0.0",
     "uuid": "9.0.0"
   },