@trayio/tray-openapi 0.0.1-beta

package/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023 Tray.io, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+This module speeds up the development process of creating a new Tray CDK connector by parsing an OpenAPI specification file for a given API and generating operation handlers, meta data, input and output types.
+
+This beta functionality is available from the @trayio/cdk-cli module via the `tray-cdk import-openapi-spec` command. If you encounter any issues that you wish the team to investigate further please supply us with OpenApi specification you are importing and the `errors.json` that has been generated during the import process.
+
+These are the features that are currently supported/unsupported:
+- OpenAPI spec interpretation:
+    - Supported:
+        - schema internal component references
+        - JSON OpenAPI specification version 3
+        - If your version is older you can use this to update it: [Swagger Editor](https://editor.swagger.io/) (From the top menu bar, select edit, convert to Open API 3, you can also use this to convert from YAML to JSON)
+    - Unsupported:
+        - Swagger API version 2
+        - YAML spec files
+        - open API specs with multiple server URLs, manually edit the file to set your desired server to the first in the array
+        - recursive schema references
+        - external schema references
+        - schema references that target nested components
+- Authentication
+    - Unsupported:
+        - generation of Auth type
+        - handlers utilising the auth token in handlers
+- Input/output types:
+    - Supported:
+        - Primitive types: number, string, boolean
+        - Objects
+        - 2XX response schemas
+        - Empty input/output
+    - Unsupported:
+        - enum types
+        - array types
+        - non 2XX response schemas
+- Request/Response types:
+    - Supported:
+        - Json request/response
+    - Unsupported:
+        - xml request/response
+        - text request/response
+        - file request/response
+        - form request/response

package/dist/OpenApiCodecs.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPISchema, Parameter, Path } from './OpenApiTypeDescriptors';
+export declare const openApiSpecCodec: import("commons/dist/codec/Codec").Codec<OpenAPISchema>;
+export declare const pathCodec: import("commons/dist/codec/Codec").Codec<Path>;
+export declare const parameterSchemaCodec: import("commons/dist/codec/Codec").Codec<Parameter>;
+//# sourceMappingURL=OpenApiCodecs.d.ts.map

package/dist/OpenApiCodecs.d.ts.map

@@ -0,0 +1 @@
+{"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,yDAE5B,CAAC;AAEF,eAAO,MAAM,SAAS,gDAErB,CAAC;AAEF,eAAO,MAAM,oBAAoB,qDAEhC,CAAC"}

package/dist/OpenApiCodecs.js

@@ -0,0 +1,8 @@
+"use strict";
+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.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

@@ -0,0 +1,17 @@
+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';
+export declare class OpenApiSchemaImporter {
+    private generator;
+    private fileStorage;
+    constructor(generator: Generator, fileStorage: FileStorage);
+    buildConnector(openApiSpecPath: string, connectorName: string): TE.TaskEither<Error, BuildConnectorResponse>;
+    private generateOperationFromPath;
+    private decodeOperation;
+    private getOpenApiSpec;
+    private generateHandlerFilesAndOperationJson;
+    private generateConnectorDirectory;
+    private generateOperationDirectory;
+}
+//# sourceMappingURL=OpenApiSchemaImporter.d.ts.map

package/dist/OpenApiSchemaImporter.d.ts.map

@@ -0,0 +1 @@
+{"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;IAgF5C,OAAO,CAAC,0BAA0B;IAwBlC,OAAO,CAAC,0BAA0B;CAclC"}

package/dist/OpenApiSchemaImporter.js

@@ -0,0 +1,138 @@
+"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 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");
+const BufferExtensions_1 = require("@trayio/commons/buffer/BufferExtensions");
+const stream_1 = require("stream");
+const OpenApiCodecs_1 = require("./OpenApiCodecs");
+const GenerateHandler_1 = require("./file-generators/GenerateHandler");
+const GenerateOutput_1 = require("./file-generators/types/GenerateOutput");
+const GenerateInputTypes_1 = require("./file-generators/types/GenerateInputTypes");
+const GenerateHandlerTest_1 = require("./file-generators/GenerateHandlerTest");
+const GenerateOperationJson_1 = require("./file-generators/GenerateOperationJson");
+const GenerateInputSchema_1 = require("./file-generators/types/GenerateInputSchema");
+const OpenApiSchemaTransformer_1 = require("./OpenApiSchemaTransformer");
+class OpenApiSchemaImporter {
+    constructor(generator, fileStorage) {
+        this.generator = generator;
+        this.fileStorage = fileStorage;
+    }
+    buildConnector(openApiSpecPath, connectorName) {
+        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 TE.left(new Error('OpenAPI spec does not contain any paths'));
+            }
+            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],
+                })),
+            })));
+        }), 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') {
+                    return Object.assign(Object.assign({}, acc), { errors: [...acc.errors, curr] });
+                }
+                return Object.assign(Object.assign({}, acc), { successes: [...acc.successes, curr] });
+            }, { successes: [], errors: [] });
+            return buildConnectorResponse;
+        }));
+    }
+    generateOperationFromPath(path, connectorPath, baseUrl, connectorName) {
+        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.kebabCase)(decodedPath.operationId)}`, baseUrl, path.path, connectorName, inputs, outputs)), TE.map(() => ({
+            tag: 'success',
+            httpMethod: route.method,
+            path: path.path,
+        })), TE.orElseW((error) => TE.right({
+            tag: 'error',
+            httpMethod: route.method,
+            path: path.path,
+            errorMessage: error.message,
+        }))))(path.routes));
+    }
+    decodeOperation(path, httpPath, method) {
+        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, 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({
+            content: stream_1.Readable.from(content),
+            key: `${operationPath}/${fileName}`,
+            metadata: { name: fileName },
+        }, O.none);
+        const operationName = path.operationId;
+        const operationFileGenerationTasks = {
+            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),
+                httpMethod: method,
+                baseUrl,
+                httpPath,
+                input,
+            })), 
+            // TODO: Why does this throw unhelpful errors?
+            TE.chain((handlerInput) => writeFile(handlerInput, 'handler.ts'))),
+            handlerTest: (0, function_1.pipe)(TE.fromEither((0, GenerateHandlerTest_1.generateHandlerTest)({
+                operationNameCamelCase: (0, lodash_1.camelCase)(operationName),
+                input,
+                output,
+            })), TE.chain((handlerInput) => writeFile(handlerInput, 'handler.test.ts'))),
+            generateOutputType: (0, function_1.pipe)((0, GenerateOutput_1.generateOutputTypes)(operationName, output), TE.chain((outputType) => writeFile(outputType, 'output.ts'))),
+            generateInputType: (0, function_1.pipe)((0, GenerateInputTypes_1.generateInputTypes)(operationName, input), TE.chain((inputType) => writeFile(inputType, 'input.ts'))),
+            operationJson: (0, GenerateOperationJson_1.generateOperationJson)(this.fileStorage, operationPath, operationName, (0, lodash_1.kebabCase)(operationName), path.description),
+        };
+        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, 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),
+        }), 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, function_1.pipe)(TE.tryCatch(this.fileStorage.createDirectory(`${connectorPath}/src/${(0, lodash_1.kebabCase)(operationName)}`), (error) => new Error(`Failed to create operation directory: ${error}`)), TE.map(() => `${connectorPath}/src/${(0, lodash_1.kebabCase)(operationName)}`));
+    }
+}
+exports.OpenApiSchemaImporter = OpenApiSchemaImporter;

package/dist/OpenApiSchemaImporter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OpenApiSchemaImporter.test.d.ts.map

package/dist/OpenApiSchemaImporter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApiSchemaImporter.test.d.ts","sourceRoot":"","sources":["../src/OpenApiSchemaImporter.test.ts"],"names":[],"mappings":""}

package/dist/OpenApiSchemaImporter.test.js

@@ -0,0 +1,85 @@
+"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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const 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"));
+describe('openApiSchemaImporter', () => {
+    const generator = new NodeFsGenerator_1.NodeFsGenerator();
+    const fileStorage = new FakeFileStorage_1.FakeFileStorage();
+    const openApiSchemaImporter = new OpenApiSchemaImporter_1.OpenApiSchemaImporter(generator, fileStorage);
+    let result;
+    const spec = 'test-openapi-spec.json';
+    beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        fileStorage.write({
+            key: `${__dirname}/${spec}`,
+            metadata: { name: spec },
+            content: stream_1.Readable.from(Buffer.from(JSON.stringify(openApiSpec))),
+        });
+        result = yield openApiSchemaImporter.buildConnector(`${__dirname}/${spec}`, 'testConnector')();
+    }));
+    afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield fs.rm(`${process.cwd()}/test/`, { recursive: true, force: true });
+    }));
+    it('should import successfully', () => {
+        const buildConnectorResponse = E.getOrElse((error) => {
+            console.error(error);
+            throw new Error('Should have been right');
+        })(result);
+        expect(buildConnectorResponse.successes.length).toEqual(1);
+        expect(buildConnectorResponse.errors.length).toEqual(1);
+    });
+    it('should generate a operation handler', () => {
+        expect(fileStorage.files.has(`/test-connector/src/get-post/handler.ts`)).toEqual(true);
+    });
+    it('should generate an operation handler test', () => {
+        expect(fileStorage.files.has(`/test-connector/src/get-post/handler.test.ts`)).toEqual(true);
+    });
+    it('should generate an operation.json', () => {
+        expect(fileStorage.files.has(`/test-connector/src/get-post/operation.json`)).toEqual(true);
+    });
+    it('should generate an output.ts', () => {
+        expect(fileStorage.files.has(`/test-connector/src/get-post/output.ts`)).toEqual(true);
+    });
+    it('should generate a operation directory', () => {
+        expect(fileStorage.files.has(`/test-connector/src/get-post`)).toEqual(true);
+    });
+    it('should not generate a operation directory when failing to decode', () => {
+        expect(fileStorage.files.has(`/test-connector/src/update-post`)).toEqual(false);
+    });
+});

package/dist/OpenApiSchemaTransformer.d.ts

@@ -0,0 +1,9 @@
+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) => E.Either<Error, BaseOpenApiSpec>;
+//# sourceMappingURL=OpenApiSchemaTransformer.d.ts.map

package/dist/OpenApiSchemaTransformer.d.ts.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,68 @@
+"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 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;
+exports.isObjectWithParameters = isObjectWithParameters;
+const getMergedParameters = (pathValue, httpMethodValue) => {
+    if (!Array.isArray(pathValue.parameters)) {
+        throw new Error('Path parameters is not an array');
+    }
+    // if the method contains existing parameters, we merge them with the path parameters
+    if ('parameters' in httpMethodValue &&
+        Array.isArray(httpMethodValue.parameters)) {
+        return [...httpMethodValue.parameters, ...pathValue.parameters];
+    }
+    return pathValue.parameters;
+};
+exports.getMergedParameters = getMergedParameters;
+const mergePathLevelParamsIntoHttpMethod = (openApiSpec) => {
+    const paths = Object.entries(openApiSpec.paths).reduce((pathAcc, [pathName, pathValue]) => {
+        // if the path doesn't contain top level params, we just return it
+        if (!(0, exports.isObjectWithParameters)(pathValue)) {
+            pathAcc[pathName] = pathValue;
+            return pathAcc;
+        }
+        const updatedPathValue = Object.entries(pathValue).reduce((methodAcc, [httpMethodName, httpMethodValue]) => {
+            if (!(0, exports.isObject)(httpMethodValue)) {
+                throw new Error('Http method value is not an object');
+            }
+            // we skip adding the parameters object to the path object
+            if (httpMethodName === 'parameters') {
+                return methodAcc;
+            }
+            const parameters = (0, exports.getMergedParameters)(pathValue, httpMethodValue);
+            methodAcc[httpMethodName] = Object.assign(Object.assign({}, httpMethodValue), { parameters });
+            return methodAcc;
+        }, {});
+        pathAcc[pathName] = updatedPathValue;
+        return pathAcc;
+    }, {});
+    return E.right(Object.assign(Object.assign({}, openApiSpec), { paths }));
+};
+exports.mergePathLevelParamsIntoHttpMethod = mergePathLevelParamsIntoHttpMethod;

package/dist/OpenApiSchemaTransformer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OpenApiSchemaTransformer.test.d.ts.map

package/dist/OpenApiSchemaTransformer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApiSchemaTransformer.test.d.ts","sourceRoot":"","sources":["../src/OpenApiSchemaTransformer.test.ts"],"names":[],"mappings":""}

package/dist/OpenApiSchemaTransformer.test.js

@@ -0,0 +1,118 @@
+"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 });
+const E = __importStar(require("fp-ts/Either"));
+const OpenApiSchemaTransformer_1 = require("./OpenApiSchemaTransformer");
+describe('mergePathLevelParamsIntoHttpMethod', () => {
+    it('should merge path level parameters into HTTP methods', () => {
+        const openApiSpec = {
+            openapi: '3.0.0',
+            info: {
+                version: '1.0.0',
+                title: 'JSON Placeholder API',
+                description: 'See https://jsonplaceholder.typicode.com/',
+            },
+            servers: [
+                {
+                    url: 'https://jsonplaceholder.typicode.com',
+                },
+            ],
+            paths: {
+                '/path': {
+                    parameters: [{ name: 'param1', in: 'query', required: false }],
+                    get: {
+                        parameters: [{ name: 'param2', in: 'query', required: true }],
+                    },
+                },
+            },
+        };
+        const result = (0, OpenApiSchemaTransformer_1.mergePathLevelParamsIntoHttpMethod)(openApiSpec);
+        E.fold((error) => {
+            throw new Error(`Test failed with error: ${error.message}`);
+        }, (updatedOpenApiSpec) => {
+            expect(updatedOpenApiSpec.paths['/path'].get.parameters).toEqual([
+                { name: 'param2', in: 'query', required: true },
+                { name: 'param1', in: 'query', required: false },
+            ]);
+        })(result);
+    });
+    it('should return the original spec if no top level parameters', () => {
+        const openApiSpec = {
+            openapi: '3.0.0',
+            info: {
+                version: '1.0.0',
+                title: 'JSON Placeholder API',
+                description: 'See https://jsonplaceholder.typicode.com/',
+            },
+            servers: [
+                {
+                    url: 'https://jsonplaceholder.typicode.com',
+                },
+            ],
+            paths: {
+                '/path': {
+                    get: {
+                        parameters: [{ name: 'param2', in: 'query', required: true }],
+                    },
+                },
+            },
+        };
+        const result = (0, OpenApiSchemaTransformer_1.mergePathLevelParamsIntoHttpMethod)(openApiSpec);
+        E.fold((error) => {
+            throw new Error(`Test failed with error: ${error.message}`);
+        }, (updatedOpenApiSpec) => {
+            expect(updatedOpenApiSpec).toEqual(openApiSpec);
+        })(result);
+    });
+    it('should add path level parameters into HTTP methods, if no method params already exist', () => {
+        const openApiSpec = {
+            openapi: '3.0.0',
+            info: {
+                version: '1.0.0',
+                title: 'JSON Placeholder API',
+                description: 'See https://jsonplaceholder.typicode.com/',
+            },
+            servers: [
+                {
+                    url: 'https://jsonplaceholder.typicode.com',
+                },
+            ],
+            paths: {
+                '/path': {
+                    parameters: [{ name: 'param1', in: 'query', required: false }],
+                    get: {},
+                },
+            },
+        };
+        const result = (0, OpenApiSchemaTransformer_1.mergePathLevelParamsIntoHttpMethod)(openApiSpec);
+        E.fold((error) => {
+            throw new Error(`Test failed with error: ${error.message}`);
+        }, (updatedOpenApiSpec) => {
+            expect(updatedOpenApiSpec.paths['/path'].get.parameters).toEqual([
+                { name: 'param1', in: 'query', required: false },
+            ]);
+        })(result);
+    });
+});

package/dist/OpenApiTypeDescriptors.d.ts

@@ -0,0 +1,109 @@
+import * as t from 'io-ts';
+import * as O from 'fp-ts/Option';
+export type FlatPath = {
+    path: string;
+    routes: {
+        method: OpenApiHttpMethod;
+        path: unknown;
+    }[];
+};
+export type Server = {
+    url: string;
+};
+export type BaseOpenApiSpec = {
+    openapi: string;
+    info: {
+        version: string;
+        title: string;
+        description: string;
+    };
+    servers: Server[];
+    paths: Record<string, Record<string, unknown>>;
+};
+export type BaseOperation = {
+    httpMethod: OpenApiHttpMethod;
+    path: string;
+};
+export type OperationError = BaseOperation & {
+    tag: 'error';
+    errorMessage: string;
+};
+export type OperationSuccess = BaseOperation & {
+    tag: 'success';
+};
+export type Operation = OperationError | OperationSuccess;
+export type BuildConnectorResponse = {
+    successes: OperationSuccess[];
+    errors: OperationError[];
+};
+export type Path = {
+    description: string;
+    tags: O.Option<string[]>;
+    operationId: string;
+    parameters: O.Option<Parameter[]>;
+    requestBody: O.Option<RequestBody>;
+    responses: O.Option<Responses>;
+};
+export type Parameter = {
+    name: string;
+    in: string;
+    description: string;
+    required: O.Option<boolean>;
+    schema: SchemaObject;
+};
+export type RequestBody = {
+    content: Record<string, MediaTypeObject>;
+};
+export interface MediaTypeObject {
+    schema: O.Option<SchemaObject>;
+}
+export type Responses = Record<string, Response>;
+export type Response = {
+    description: string;
+    content: O.Option<Record<string, MediaTypeObject>>;
+};
+export type OpenApiHttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type ComponentSchema = {
+    schemas: O.Option<Record<string, SchemaObject>>;
+};
+export type OpenAPISchema = {
+    openapi: string;
+    info: {
+        title: string;
+        description: string;
+        version: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    paths: Record<string, Partial<Record<OpenApiHttpMethod, Path>>>;
+    components: ComponentSchema;
+};
+export type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+export interface ArraySchemaObject extends BaseSchemaObject {
+    type: 'array';
+    items: SchemaObject;
+}
+export type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+export interface NonArraySchemaObject extends BaseSchemaObject {
+    type: O.Option<NonArraySchemaObjectType>;
+}
+export type BaseSchemaObject = {
+    title: O.Option<string>;
+    additionalProperties: O.Option<boolean | SchemaObject>;
+    properties: O.Option<Record<string, SchemaObject>>;
+    required: O.Option<string[]>;
+    allOf: O.Option<SchemaObject[]>;
+    oneOf: O.Option<SchemaObject[]>;
+    anyOf: O.Option<SchemaObject[]>;
+    not: O.Option<SchemaObject>;
+    in: O.Option<string>;
+};
+export declare const baseSchemaObjectSchemaTypeDescriptor: t.Type<BaseSchemaObject, unknown>;
+export declare const schemaObjectTypeDescriptor: t.Type<SchemaObject, unknown>;
+export declare const schemaObjectTypeCodec: import("commons/dist/codec/Codec").Codec<SchemaObject>;
+export declare const parameterSchemaTypeDescriptor: t.Type<Parameter, unknown>;
+export declare const openApiSpecPathTypeDescriptor: t.Type<Path, unknown>;
+export declare const openApiSpecTypeDescriptor: t.Type<OpenAPISchema, unknown>;
+export {};
+//# sourceMappingURL=OpenApiTypeDescriptors.d.ts.map