@trayio/tray-openapi 5.35.0-unstable.fd7158a → 6.0.0

package/dist/OpenApiCodecs.d.ts

@@ -1,208 +1,5 @@
-export declare const openApiSpecCodec: import("@trayio/commons/dist/codec/Codec").Codec<{
-    readonly openapi: string;
-    readonly info: {
-        readonly title: string;
-        readonly description: string;
-        readonly version: string;
-    };
-    readonly servers: {
-        readonly url: string;
-    }[];
-    readonly paths: {
-        [x: string]: {
-            readonly get?: {
-                readonly description: import("effect/Option").Option<string>;
-                readonly summary: import("effect/Option").Option<string>;
-                readonly tags: import("effect/Option").Option<string[]>;
-                readonly operationId: string;
-                readonly parameters: import("effect/Option").Option<{
-                    readonly required: import("effect/Option").Option<boolean>;
-                    readonly in: string;
-                    readonly schema: import("./OpenApiTypeDescriptors").SchemaObject;
-                    readonly description: import("effect/Option").Option<string>;
-                    readonly name: string;
-                }[]>;
-                readonly requestBody: import("effect/Option").Option<{
-                    readonly content: {
-                        [x: string]: {
-                            readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                        };
-                    };
-                }>;
-                readonly responses: import("effect/Option").Option<{
-                    [x: string]: {
-                        readonly content: import("effect/Option").Option<{
-                            [x: string]: {
-                                readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                            };
-                        }>;
-                        readonly description: string;
-                    };
-                }>;
-            } | undefined;
-            readonly post?: {
-                readonly description: import("effect/Option").Option<string>;
-                readonly summary: import("effect/Option").Option<string>;
-                readonly tags: import("effect/Option").Option<string[]>;
-                readonly operationId: string;
-                readonly parameters: import("effect/Option").Option<{
-                    readonly required: import("effect/Option").Option<boolean>;
-                    readonly in: string;
-                    readonly schema: import("./OpenApiTypeDescriptors").SchemaObject;
-                    readonly description: import("effect/Option").Option<string>;
-                    readonly name: string;
-                }[]>;
-                readonly requestBody: import("effect/Option").Option<{
-                    readonly content: {
-                        [x: string]: {
-                            readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                        };
-                    };
-                }>;
-                readonly responses: import("effect/Option").Option<{
-                    [x: string]: {
-                        readonly content: import("effect/Option").Option<{
-                            [x: string]: {
-                                readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                            };
-                        }>;
-                        readonly description: string;
-                    };
-                }>;
-            } | undefined;
-            readonly put?: {
-                readonly description: import("effect/Option").Option<string>;
-                readonly summary: import("effect/Option").Option<string>;
-                readonly tags: import("effect/Option").Option<string[]>;
-                readonly operationId: string;
-                readonly parameters: import("effect/Option").Option<{
-                    readonly required: import("effect/Option").Option<boolean>;
-                    readonly in: string;
-                    readonly schema: import("./OpenApiTypeDescriptors").SchemaObject;
-                    readonly description: import("effect/Option").Option<string>;
-                    readonly name: string;
-                }[]>;
-                readonly requestBody: import("effect/Option").Option<{
-                    readonly content: {
-                        [x: string]: {
-                            readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                        };
-                    };
-                }>;
-                readonly responses: import("effect/Option").Option<{
-                    [x: string]: {
-                        readonly content: import("effect/Option").Option<{
-                            [x: string]: {
-                                readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                            };
-                        }>;
-                        readonly description: string;
-                    };
-                }>;
-            } | undefined;
-            readonly patch?: {
-                readonly description: import("effect/Option").Option<string>;
-                readonly summary: import("effect/Option").Option<string>;
-                readonly tags: import("effect/Option").Option<string[]>;
-                readonly operationId: string;
-                readonly parameters: import("effect/Option").Option<{
-                    readonly required: import("effect/Option").Option<boolean>;
-                    readonly in: string;
-                    readonly schema: import("./OpenApiTypeDescriptors").SchemaObject;
-                    readonly description: import("effect/Option").Option<string>;
-                    readonly name: string;
-                }[]>;
-                readonly requestBody: import("effect/Option").Option<{
-                    readonly content: {
-                        [x: string]: {
-                            readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                        };
-                    };
-                }>;
-                readonly responses: import("effect/Option").Option<{
-                    [x: string]: {
-                        readonly content: import("effect/Option").Option<{
-                            [x: string]: {
-                                readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                            };
-                        }>;
-                        readonly description: string;
-                    };
-                }>;
-            } | undefined;
-            readonly delete?: {
-                readonly description: import("effect/Option").Option<string>;
-                readonly summary: import("effect/Option").Option<string>;
-                readonly tags: import("effect/Option").Option<string[]>;
-                readonly operationId: string;
-                readonly parameters: import("effect/Option").Option<{
-                    readonly required: import("effect/Option").Option<boolean>;
-                    readonly in: string;
-                    readonly schema: import("./OpenApiTypeDescriptors").SchemaObject;
-                    readonly description: import("effect/Option").Option<string>;
-                    readonly name: string;
-                }[]>;
-                readonly requestBody: import("effect/Option").Option<{
-                    readonly content: {
-                        [x: string]: {
-                            readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                        };
-                    };
-                }>;
-                readonly responses: import("effect/Option").Option<{
-                    [x: string]: {
-                        readonly content: import("effect/Option").Option<{
-                            [x: string]: {
-                                readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                            };
-                        }>;
-                        readonly description: string;
-                    };
-                }>;
-            } | undefined;
-        };
-    };
-    readonly components: {
-        readonly schemas: import("effect/Option").Option<{
-            [x: string]: import("./OpenApiTypeDescriptors").SchemaObject;
-        }>;
-    };
-}>;
-export declare const pathCodec: import("@trayio/commons/dist/codec/Codec").Codec<{
-    readonly description: import("effect/Option").Option<string>;
-    readonly summary: import("effect/Option").Option<string>;
-    readonly tags: import("effect/Option").Option<string[]>;
-    readonly operationId: string;
-    readonly parameters: import("effect/Option").Option<{
-        readonly required: import("effect/Option").Option<boolean>;
-        readonly in: string;
-        readonly schema: import("./OpenApiTypeDescriptors").SchemaObject;
-        readonly description: import("effect/Option").Option<string>;
-        readonly name: string;
-    }[]>;
-    readonly requestBody: import("effect/Option").Option<{
-        readonly content: {
-            [x: string]: {
-                readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-            };
-        };
-    }>;
-    readonly responses: import("effect/Option").Option<{
-        [x: string]: {
-            readonly content: import("effect/Option").Option<{
-                [x: string]: {
-                    readonly schema: import("effect/Option").Option<import("./OpenApiTypeDescriptors").SchemaObject>;
-                };
-            }>;
-            readonly description: string;
-        };
-    }>;
-}>;
-export declare const parameterSchemaCodec: import("@trayio/commons/dist/codec/Codec").Codec<{
-    readonly required: import("effect/Option").Option<boolean>;
-    readonly in: string;
-    readonly schema: import("./OpenApiTypeDescriptors").SchemaObject;
-    readonly description: import("effect/Option").Option<string>;
-    readonly name: string;
-}>;
+import { OpenAPISchema, Parameter, Path } from './OpenApiTypeDescriptors';
+export declare const openApiSpecCodec: import("@trayio/commons/dist/codec/Codec").Codec<OpenAPISchema>;
+export declare const pathCodec: import("@trayio/commons/dist/codec/Codec").Codec<Path>;
+export declare const parameterSchemaCodec: import("@trayio/commons/dist/codec/Codec").Codec<Parameter>;
 //# sourceMappingURL=OpenApiCodecs.d.ts.map

package/dist/OpenApiCodecs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpenApiCodecs.d.ts","sourceRoot":"","sources":["../src/OpenApiCodecs.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0C,CAAC;AAExE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8C,CAAC;AAErE,eAAO,MAAM,oBAAoB;;;;;;EAA8C,CAAC"}
+{"version":3,"file":"OpenApiCodecs.d.ts","sourceRoot":"","sources":["../src/OpenApiCodecs.ts"],"names":[],"mappings":"AACA,OAAO,EACN,aAAa,EACb,SAAS,EACT,IAAI,EAIJ,MAAM,0BAA0B,CAAC;AAElC,eAAO,MAAM,gBAAgB,iEAE5B,CAAC;AAEF,eAAO,MAAM,SAAS,wDAErB,CAAC;AAEF,eAAO,MAAM,oBAAoB,6DAEhC,CAAC"}

package/dist/OpenApiCodecs.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parameterSchemaCodec = exports.pathCodec = exports.openApiSpecCodec = void 0;
 const TypeCodec_1 = require("@trayio/commons/codec/TypeCodec");
 const OpenApiTypeDescriptors_1 = require("./OpenApiTypeDescriptors");
-exports.openApiSpecCodec = TypeCodec_1.TypeCodec.fromSchema(OpenApiTypeDescriptors_1.openApiSpecSchema);
-exports.pathCodec = TypeCodec_1.TypeCodec.fromSchema(OpenApiTypeDescriptors_1.openApiSpecPathSchema);
-exports.parameterSchemaCodec = TypeCodec_1.TypeCodec.fromSchema(OpenApiTypeDescriptors_1.parameterSchemaSchema);
+exports.openApiSpecCodec = TypeCodec_1.TypeCodec.fromDescriptor(OpenApiTypeDescriptors_1.openApiSpecTypeDescriptor);
+exports.pathCodec = TypeCodec_1.TypeCodec.fromDescriptor(OpenApiTypeDescriptors_1.openApiSpecPathTypeDescriptor);
+exports.parameterSchemaCodec = TypeCodec_1.TypeCodec.fromDescriptor(OpenApiTypeDescriptors_1.parameterSchemaTypeDescriptor);

package/dist/OpenApiSchemaImporter.d.ts

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+import * as TE from 'fp-ts/TaskEither';
 import { FileStorage } from '@trayio/commons/file/File';
 import { Generator } from '@trayio/generator/generator/Generator';
 import { BuildConnectorResponse } from './OpenApiTypeDescriptors';
@@ -6,7 +6,7 @@ export declare class OpenApiSchemaImporter {
     private generator;
     private fileStorage;
     constructor(generator: Generator, fileStorage: FileStorage);
-    buildConnector(openApiSpecPath: string, connectorName: string): Effect.Effect<BuildConnectorResponse, Error>;
+    buildConnector(openApiSpecPath: string, connectorName: string): TE.TaskEither<Error, BuildConnectorResponse>;
     private generateOperationFromPath;
     private decodeOperation;
     private getOpenApiSpec;

package/dist/OpenApiSchemaImporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpenApiSchemaImporter.d.ts","sourceRoot":"","sources":["../src/OpenApiSchemaImporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAwB,MAAM,QAAQ,CAAC;AAItD,OAAO,EAAQ,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAGlE,OAAO,EAEN,sBAAsB,EAMtB,MAAM,0BAA0B,CAAC;AAalC,qBAAa,qBAAqB;IACrB,OAAO,CAAC,SAAS;IAAa,OAAO,CAAC,WAAW;gBAAzC,SAAS,EAAE,SAAS,EAAU,WAAW,EAAE,WAAW;IAE1E,cAAc,CACb,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM,GACnB,MAAM,CAAC,MAAM,CAAC,sBAAsB,EAAE,KAAK,CAAC;IAsD/C,OAAO,CAAC,yBAAyB;IAuDjC,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,cAAc;IAkCtB,OAAO,CAAC,oCAAoC;IA+F5C,OAAO,CAAC,0BAA0B;IAwBlC,OAAO,CAAC,0BAA0B;CAclC"}
+{"version":3,"file":"OpenApiSchemaImporter.d.ts","sourceRoot":"","sources":["../src/OpenApiSchemaImporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AASvC,OAAO,EAAQ,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAGlE,OAAO,EAEN,sBAAsB,EAMtB,MAAM,0BAA0B,CAAC;AAalC,qBAAa,qBAAqB;IACrB,OAAO,CAAC,SAAS;IAAa,OAAO,CAAC,WAAW;gBAAzC,SAAS,EAAE,SAAS,EAAU,WAAW,EAAE,WAAW;IAE1E,cAAc,CACb,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM,GACnB,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,sBAAsB,CAAC;IAoD/C,OAAO,CAAC,yBAAyB;IAyDjC,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,cAAc;IAoCtB,OAAO,CAAC,oCAAoC;IA2F5C,OAAO,CAAC,0BAA0B;IAwBlC,OAAO,CAAC,0BAA0B;CAclC"}

package/dist/OpenApiSchemaImporter.js

@@ -1,7 +1,35 @@
 "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.OpenApiSchemaImporter = void 0;
-const effect_1 = require("effect");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const E = __importStar(require("fp-ts/Either"));
+const O = __importStar(require("fp-ts/Option"));
+const function_1 = require("fp-ts/function");
+const Array_1 = require("fp-ts/Array");
+const Apply_1 = require("fp-ts/Apply");
 const json_ref_resolver_1 = require("@stoplight/json-ref-resolver");
 const StringExtensions_1 = require("@trayio/commons/string/StringExtensions");
 const lodash_1 = require("lodash");
@@ -23,18 +51,18 @@ class OpenApiSchemaImporter {
         this.fileStorage = fileStorage;
     }
     buildConnector(openApiSpecPath, connectorName) {
-        return (0, effect_1.pipe)(this.generateConnectorDirectory(connectorName), effect_1.Effect.bindTo('connectorPath'), effect_1.Effect.bind('openApiSpec', () => this.getOpenApiSpec(openApiSpecPath)), effect_1.Effect.bind('paths', ({ openApiSpec }) => {
+        return (0, function_1.pipe)(this.generateConnectorDirectory(connectorName), TE.bindTo('connectorPath'), TE.bind('openApiSpec', () => this.getOpenApiSpec(openApiSpecPath)), TE.bind('paths', ({ openApiSpec }) => {
             if (openApiSpec.paths === undefined) {
-                return effect_1.Effect.fail(new Error('OpenAPI spec does not contain any paths'));
+                return TE.left(new Error('OpenAPI spec does not contain any paths'));
             }
-            return effect_1.Effect.succeed(Object.keys(openApiSpec.paths).map((path) => ({
+            return TE.right(Object.keys(openApiSpec.paths).map((path) => ({
                 path,
                 routes: Object.keys(openApiSpec.paths[path]).map((route) => ({
                     method: route,
                     path: openApiSpec.paths[path][route],
                 })),
             })));
-        }), effect_1.Effect.flatMap(({ openApiSpec, connectorPath, paths }) => effect_1.Effect.forEach((path) => this.generateOperationFromPath(path, connectorPath, openApiSpec.servers[0].url, connectorName))(paths)), effect_1.Effect.map((operation) => {
+        }), TE.chain(({ openApiSpec, connectorPath, paths }) => (0, Array_1.traverse)(TE.ApplicativeSeq)((path) => this.generateOperationFromPath(path, connectorPath, openApiSpec.servers[0].url, connectorName))(paths)), TE.map((operation) => {
             const flatOperations = operation.flat();
             const buildConnectorResponse = flatOperations.reduce((acc, curr) => {
                 if (curr.tag === 'error') {
@@ -52,11 +80,11 @@ class OpenApiSchemaImporter {
         }));
     }
     generateOperationFromPath(path, connectorPath, baseUrl, connectorName) {
-        return (0, effect_1.pipe)(effect_1.Effect.forEach((route) => (0, effect_1.pipe)(this.decodeOperation(route.path, path.path, route.method), effect_1.Effect.bindTo('decodedPath'), effect_1.Effect.flatMap(({ decodedPath }) => (0, effect_1.pipe)(this.generateOperationDirectory(connectorPath, decodedPath.operationId), effect_1.Effect.map((operationDirectory) => ({ operationDirectory })), effect_1.Effect.bind('inputs', () => (0, GenerateInputSchema_1.generateInputSchema)(decodedPath)), effect_1.Effect.bind('outputs', () => (0, GenerateOutput_1.generateOutputSchema)(decodedPath.responses)), effect_1.Effect.bind('decodedPath', () => effect_1.Effect.succeed(decodedPath)))), effect_1.Effect.flatMap(({ inputs, outputs, decodedPath }) => this.generateHandlerFilesAndOperationJson(route.method, decodedPath, `${connectorPath}/src/${(0, lodash_1.snakeCase)(decodedPath.operationId)}`, baseUrl, path.path, connectorName, inputs, outputs)), effect_1.Effect.map(() => ({
+        return (0, function_1.pipe)((0, Array_1.traverse)(TE.ApplicativeSeq)((route) => (0, function_1.pipe)(this.decodeOperation(route.path, path.path, route.method), TE.bindTo('decodedPath'), TE.chain(({ decodedPath }) => (0, function_1.pipe)(this.generateOperationDirectory(connectorPath, decodedPath.operationId), TE.bind('inputs', () => TE.fromEither((0, GenerateInputSchema_1.generateInputSchema)(decodedPath))), TE.bind('outputs', () => (0, GenerateOutput_1.generateOutputSchema)(decodedPath.responses)), TE.bind('decodedPath', () => TE.right(decodedPath)))), TE.chain(({ inputs, outputs, decodedPath }) => this.generateHandlerFilesAndOperationJson(route.method, decodedPath, `${connectorPath}/src/${(0, lodash_1.snakeCase)(decodedPath.operationId)}`, baseUrl, path.path, connectorName, inputs, outputs)), TE.map(() => ({
             tag: 'success',
             httpMethod: route.method,
             path: path.path,
-        })), effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+        })), TE.orElseW((error) => TE.right({
             tag: 'error',
             httpMethod: route.method,
             path: path.path,
@@ -64,20 +92,14 @@ class OpenApiSchemaImporter {
         }))))(path.routes));
     }
     decodeOperation(path, httpPath, method) {
-        return (0, effect_1.pipe)(OpenApiCodecs_1.pathCodec.decode(path), effect_1.Effect.mapError((error) => new Error(`Failed to decode httpPath: ${httpPath} and method: ${method} : ${error}`)));
+        return (0, function_1.pipe)(TE.fromEither(OpenApiCodecs_1.pathCodec.decode(path)), TE.mapLeft((error) => new Error(`Failed to decode httpPath: ${httpPath} and method: ${method} : ${error}`)));
     }
     getOpenApiSpec(openApiSpecPath) {
-        return (0, effect_1.pipe)(this.fileStorage.read(openApiSpecPath), effect_1.Effect.flatMap((openApiSpec) => BufferExtensions_1.BufferExtensions.readableToArrayBuffer(openApiSpec.content)), effect_1.Effect.flatMap((openApiSpec) => effect_1.Either.try({
-            try: () => JSON.parse(Buffer.from(openApiSpec).toString('utf-8')),
-            catch: (error) => new Error(`Failed to parse OpenAPI spec as JSON from path ${openApiSpecPath}: ${error}`),
-        })), effect_1.Effect.flatMap((openApiSpec) => effect_1.Effect.tryPromise({
-            try: () => {
-                const resolver = new json_ref_resolver_1.Resolver({});
-                const resolvedOpenApiSpec = resolver.resolve(openApiSpec, {});
-                return resolvedOpenApiSpec;
-            },
-            catch: (reason) => new Error(`Failed to resolve references in schema: ${reason}`),
-        })), effect_1.Effect.flatMap((openApiSpec) => (0, OpenApiSchemaTransformer_1.mergePathLevelParamsIntoHttpMethod)(openApiSpec.result)));
+        return (0, function_1.pipe)(this.fileStorage.read(openApiSpecPath), TE.chain((openApiSpec) => BufferExtensions_1.BufferExtensions.readableToArrayBuffer(openApiSpec.content)), TE.chain((openApiSpec) => TE.fromEither(E.tryCatch(() => JSON.parse(Buffer.from(openApiSpec).toString('utf-8')), (error) => new Error(`Failed to parse OpenAPI spec as JSON from path ${openApiSpecPath}: ${error}`)))), TE.chain((openApiSpec) => TE.tryCatch(() => {
+            const resolver = new json_ref_resolver_1.Resolver({});
+            const resolvedOpenApiSpec = resolver.resolve(openApiSpec, {});
+            return resolvedOpenApiSpec;
+        }, (reason) => new Error(`Failed to resolve references in schema: ${reason}`))), TE.chain((openApiSpec) => TE.fromEither((0, OpenApiSchemaTransformer_1.mergePathLevelParamsIntoHttpMethod)(openApiSpec.result))));
     }
     generateHandlerFilesAndOperationJson(method, path, operationPath, baseUrl, httpPath, connectorName, input, output) {
         const writeFile = (content, fileName) => this.fileStorage.write({
@@ -87,11 +109,11 @@ class OpenApiSchemaImporter {
                 key: `${operationPath}/${fileName}`,
                 metadata: { name: fileName },
             },
-        }, effect_1.Option.none());
+        }, O.none);
         const operationName = path.operationId;
-        const handleFileCreationError = (error, fileName) => (0, effect_1.pipe)(writeFile('', fileName), effect_1.Effect.mapError(() => error));
+        const handleFileCreationError = (error, fileName) => (0, function_1.pipe)(writeFile('', fileName), TE.mapLeft(() => error));
         const operationFileGenerationTasks = {
-            handler: (0, effect_1.pipe)((0, GenerateHandler_1.generateHandler)({
+            handler: (0, function_1.pipe)(TE.fromEither((0, GenerateHandler_1.generateHandler)({
                 connectorNamePascalCase: StringExtensions_1.StringExtensions.pascalCase(connectorName),
                 operationNameCamelCase: (0, lodash_1.camelCase)(operationName),
                 operationNamePascalCase: StringExtensions_1.StringExtensions.pascalCase(operationName),
@@ -99,30 +121,30 @@ class OpenApiSchemaImporter {
                 baseUrl,
                 httpPath,
                 input,
-            }), 
+            })), 
             // TODO: Why does this throw unhelpful errors?
-            effect_1.Effect.flatMap((handlerInput) => writeFile(handlerInput, 'handler.ts')), effect_1.Effect.catchAll((error) => handleFileCreationError(error, 'handler.ts'))),
-            handlerTest: (0, effect_1.pipe)((0, GenerateHandlerTest_1.generateHandlerTest)({
+            TE.chain((handlerInput) => writeFile(handlerInput, 'handler.ts')), TE.mapLeft((error) => handleFileCreationError(error, 'handler.ts'))),
+            handlerTest: (0, function_1.pipe)(TE.fromEither((0, GenerateHandlerTest_1.generateHandlerTest)({
                 operationNameCamelCase: (0, lodash_1.camelCase)(operationName),
                 input,
                 output,
-            }), effect_1.Effect.flatMap((handlerInput) => writeFile(handlerInput, 'handler.test.ts')), effect_1.Effect.catchAll((error) => handleFileCreationError(error, 'handler.test.ts'))),
-            generateOutputType: (0, effect_1.pipe)((0, GenerateOutput_1.generateOutputTypes)(operationName, output), effect_1.Effect.flatMap((outputType) => writeFile(outputType, 'output.ts')), effect_1.Effect.catchAll((error) => handleFileCreationError(error, 'output.ts'))),
-            generateInputType: (0, effect_1.pipe)((0, GenerateInputTypes_1.generateInputTypes)(operationName, input), effect_1.Effect.flatMap((inputType) => writeFile(inputType, 'input.ts')), effect_1.Effect.catchAll((error) => handleFileCreationError(error, 'input.ts'))),
-            operationJson: (0, effect_1.pipe)((0, GenerateOperationJson_1.generateOperationJson)(operationName, path), effect_1.Effect.flatMap((operationJson) => writeFile(operationJson, 'operation.json')), effect_1.Effect.catchAll((error) => handleFileCreationError(error, 'operation.json'))),
+            })), TE.chain((handlerInput) => writeFile(handlerInput, 'handler.test.ts')), TE.mapLeft((error) => handleFileCreationError(error, 'handler.test.ts'))),
+            generateOutputType: (0, function_1.pipe)((0, GenerateOutput_1.generateOutputTypes)(operationName, output), TE.chain((outputType) => writeFile(outputType, 'output.ts')), TE.mapLeft((error) => handleFileCreationError(error, 'output.ts'))),
+            generateInputType: (0, function_1.pipe)((0, GenerateInputTypes_1.generateInputTypes)(operationName, input), TE.chain((inputType) => writeFile(inputType, 'input.ts')), TE.mapLeft((error) => handleFileCreationError(error, 'input.ts'))),
+            operationJson: (0, function_1.pipe)((0, GenerateOperationJson_1.generateOperationJson)(operationName, path), TE.chain((operationJson) => writeFile(operationJson, 'operation.json')), TE.mapLeft((error) => handleFileCreationError(error, 'operation.json'))),
         };
-        return (0, effect_1.pipe)(effect_1.Effect.all(operationFileGenerationTasks, { concurrency: 'unbounded' }), effect_1.Effect.mapError((error) => new Error(`Failed to generate files for operation: ${operationName}: ${error}`)), effect_1.Effect.map(() => undefined));
+        return (0, function_1.pipe)((0, Apply_1.sequenceS)(TE.ApplicativePar)(operationFileGenerationTasks), TE.mapLeft((error) => new Error(`Failed to generate files for operation: ${operationName}: ${error}`)), TE.map(() => undefined));
     }
     generateConnectorDirectory(connectorName) {
-        return (0, effect_1.pipe)(effect_1.Effect.succeed({
+        return (0, function_1.pipe)(TE.right({
             connectorNameTitleCase: StringExtensions_1.StringExtensions.titleCase(connectorName),
             connectorNameKebabCase: (0, lodash_1.kebabCase)(connectorName),
             connectorNamePascalCase: StringExtensions_1.StringExtensions.pascalCase(connectorName),
             connectorNameCamelCase: (0, lodash_1.camelCase)(connectorName),
-        }), effect_1.Effect.flatMap((parameters) => this.generator.generate(`${__dirname}/templates/connector-template.zip`, process.cwd(), parameters)), effect_1.Effect.map(() => `/${(0, lodash_1.kebabCase)(connectorName)}`), effect_1.Effect.mapError((error) => new Error(`Failed to generate connector directory: ${error}`)));
+        }), TE.chain((parameters) => this.generator.generate(`${__dirname}/templates/connector-template.zip`, process.cwd(), parameters)), TE.map(() => `/${(0, lodash_1.kebabCase)(connectorName)}`), TE.mapLeft((error) => new Error(`Failed to generate connector directory: ${error}`)));
     }
     generateOperationDirectory(connectorPath, operationName) {
-        return (0, effect_1.pipe)(effect_1.Effect.mapError(this.fileStorage.createDirectory(`${connectorPath}/src/${(0, lodash_1.snakeCase)(operationName)}`), (error) => new Error(`Failed to create operation directory: ${error}`)), effect_1.Effect.map(() => `${connectorPath}/src/${(0, lodash_1.snakeCase)(operationName)}`));
+        return (0, function_1.pipe)(TE.tryCatch(this.fileStorage.createDirectory(`${connectorPath}/src/${(0, lodash_1.snakeCase)(operationName)}`), (error) => new Error(`Failed to create operation directory: ${error}`)), TE.map(() => `${connectorPath}/src/${(0, lodash_1.snakeCase)(operationName)}`));
     }
 }
 exports.OpenApiSchemaImporter = OpenApiSchemaImporter;

package/dist/OpenApiSchemaImporter.unit.test.js

@@ -15,28 +15,18 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+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 });
-const effect_1 = require("effect");
 const NodeFsGenerator_1 = require("@trayio/generator/generator/NodeFsGenerator");
 const FakeFileStorage_1 = require("@trayio/commons/file/FakeFileStorage");
 const stream_1 = require("stream");
+const E = __importStar(require("fp-ts/Either"));
 const fs = __importStar(require("fs-extra"));
 const OpenApiSchemaImporter_1 = require("./OpenApiSchemaImporter");
 const openApiSpec = __importStar(require("./test-openapi-spec.json"));
@@ -47,16 +37,15 @@ describe('openApiSchemaImporter', () => {
     let result;
     const spec = 'test-openapi-spec.json';
     beforeAll(async () => {
-        // Effects are lazy: the write only happens when it is run (the fp-ts version wrote eagerly on construction).
-        await effect_1.Effect.runPromise(fileStorage.write({
+        fileStorage.write({
             reference: {
                 _tag: 'FileDescriptor',
                 key: `${__dirname}/${spec}`,
                 metadata: { name: spec },
             },
             content: stream_1.Readable.from(Buffer.from(JSON.stringify(openApiSpec))),
-        }));
-        result = await effect_1.Effect.runPromise(effect_1.Effect.either(openApiSchemaImporter.buildConnector(`${__dirname}/${spec}`, 'testConnector')));
+        });
+        result = await openApiSchemaImporter.buildConnector(`${__dirname}/${spec}`, 'testConnector')();
     });
     afterAll(async () => {
         await fs.rm(`${process.cwd()}/test-connector/`, {
@@ -65,10 +54,10 @@ describe('openApiSchemaImporter', () => {
         });
     });
     it('should import successfully', () => {
-        const buildConnectorResponse = effect_1.Either.getOrElse(result, (error) => {
+        const buildConnectorResponse = E.getOrElse((error) => {
             console.error(error);
             throw new Error('Should have been right');
-        });
+        })(result);
         console.log(buildConnectorResponse);
         console.log(fileStorage.files);
         expect(buildConnectorResponse.successes.length).toEqual(1);

package/dist/OpenApiSchemaTransformer.d.ts

@@ -1,9 +1,9 @@
-import { Either } from 'effect';
+import * as E from 'fp-ts/Either';
 import { BaseOpenApiSpec } from './OpenApiTypeDescriptors';
 export declare const isObject: (value: unknown) => value is Record<string, unknown>;
 export declare const isObjectWithParameters: (value: unknown) => value is Record<string, unknown> & {
     parameters: unknown[];
 };
 export declare const getMergedParameters: (pathValue: Record<string, unknown>, httpMethodValue: Record<string, unknown>) => unknown[];
-export declare const mergePathLevelParamsIntoHttpMethod: (openApiSpec: BaseOpenApiSpec) => Either.Either<BaseOpenApiSpec, Error>;
+export declare const mergePathLevelParamsIntoHttpMethod: (openApiSpec: BaseOpenApiSpec) => E.Either<Error, BaseOpenApiSpec>;
 //# sourceMappingURL=OpenApiSchemaTransformer.d.ts.map

package/dist/OpenApiSchemaTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpenApiSchemaTransformer.d.ts","sourceRoot":"","sources":["../src/OpenApiSchemaTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAC7B,CAAC;AAE7C,eAAO,MAAM,sBAAsB,GAClC,OAAO,OAAO,KACZ,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,UAAU,EAAE,OAAO,EAAE,CAAA;CACpB,CAAC;AAE1C,eAAO,MAAM,mBAAmB,GAC/B,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACtC,OAAO,EAcT,CAAC;AAEF,eAAO,MAAM,kCAAkC,GAC9C,aAAa,eAAe,KAC1B,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,CAkCtC,CAAC"}
+{"version":3,"file":"OpenApiSchemaTransformer.d.ts","sourceRoot":"","sources":["../src/OpenApiSchemaTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,eAAO,MAAM,QAAQ,UAAW,OAAO,qCACK,CAAC;AAE7C,eAAO,MAAM,sBAAsB,UAC3B,OAAO;gBACqC,OAAO,EAAE;CACpB,CAAC;AAE1C,eAAO,MAAM,mBAAmB,cACpB,OAAO,MAAM,EAAE,OAAO,CAAC,mBACjB,OAAO,MAAM,EAAE,OAAO,CAAC,KACtC,OAAO,EAcT,CAAC;AAEF,eAAO,MAAM,kCAAkC,gBACjC,eAAe,KAC1B,EAAE,MAAM,CAAC,KAAK,EAAE,eAAe,CAkCjC,CAAC"}

package/dist/OpenApiSchemaTransformer.js

@@ -1,7 +1,30 @@
 "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.mergePathLevelParamsIntoHttpMethod = exports.getMergedParameters = exports.isObjectWithParameters = exports.isObject = void 0;
-const effect_1 = require("effect");
+const E = __importStar(require("fp-ts/Either"));
 const isObject = (value) => typeof value === 'object' && value !== null;
 exports.isObject = isObject;
 const isObjectWithParameters = (value) => (0, exports.isObject)(value) && 'parameters' in value;
@@ -40,6 +63,6 @@ const mergePathLevelParamsIntoHttpMethod = (openApiSpec) => {
         pathAcc[pathName] = updatedPathValue;
         return pathAcc;
     }, {});
-    return effect_1.Either.right({ ...openApiSpec, paths });
+    return E.right({ ...openApiSpec, paths });
 };
 exports.mergePathLevelParamsIntoHttpMethod = mergePathLevelParamsIntoHttpMethod;