@trayio/tray-openapi 2.6.0 → 2.8.0

package/dist/file-generators/GenerateHandlerTest.test.js

@@ -0,0 +1,355 @@
+"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 GenerateHandlerTest_1 = require("./GenerateHandlerTest");
+describe('GenerateHandlerTest', () => {
+    it('should generate a handler test with inputs and outputs', () => {
+        const input = {
+            operationNameCamelCase: 'getItem',
+            input: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'integer',
+                        format: 'int64',
+                    },
+                    name: {
+                        type: 'string',
+                    },
+                },
+                required: ['id', 'name'],
+                additionalProperties: false,
+            },
+            output: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'integer',
+                        format: 'int64',
+                    },
+                    name: {
+                        type: 'string',
+                    },
+                },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        };
+        const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
+        if (E.isLeft(result)) {
+            console.log(result.left);
+            throw new Error('Expected right');
+        }
+        expect(`import { OperationHandlerTestSetup } from '@trayio/cdk-dsl/connector/operation/OperationHandlerTest';
+	import { OperationHandlerResult } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
+	import { getItemHandler } from './handler';
+	import '@trayio/cdk-runtime/connector/operation/OperationHandlerTestRunner';
+	
+	OperationHandlerTestSetup.configureHandlerTest(getItemHandler, (handlerTest) =>
+		handlerTest
+			.usingHandlerContext('test')
+			.nothingBeforeAll()
+			.testCase('should ${input.operationNameCamelCase}', (testCase) =>
+				testCase
+					.givenNothing()
+					.when(() => ({ id: 2, name: 'test' }))
+					.then(({ output }) => {
+						// console.log(output);
+						const outputValue =
+							OperationHandlerResult.getSuccessfulValueOrFail(output);
+						expect(outputValue.id).toEqual(2);
+						expect(outputValue.name).toEqual('test');
+					})
+					.finallyDoNothing()
+			)
+			.nothingAfterAll()
+	);`.replace(/\s/g, '')).toEqual(result.right.replace(/\s/g, ''));
+    });
+    it('should generate a handler test with empty inputs', () => {
+        const input = {
+            operationNameCamelCase: 'getItem',
+            input: {},
+            output: {
+                type: 'object',
+                properties: {
+                    success: {
+                        type: 'boolean',
+                    },
+                },
+                required: ['success'],
+                additionalProperties: false,
+            },
+        };
+        const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
+        if (E.isLeft(result)) {
+            console.log(result.left);
+            throw new Error('Expected right');
+        }
+        expect(`import { OperationHandlerTestSetup } from '@trayio/cdk-dsl/connector/operation/OperationHandlerTest';
+	import { OperationHandlerResult } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
+	import { getItemHandler } from './handler';
+	import '@trayio/cdk-runtime/connector/operation/OperationHandlerTestRunner';
+	
+	OperationHandlerTestSetup.configureHandlerTest(getItemHandler, (handlerTest) =>
+		handlerTest
+			.usingHandlerContext('test')
+			.nothingBeforeAll()
+			.testCase('should ${input.operationNameCamelCase}', (testCase) =>
+				testCase
+					.givenNothing()
+					.when(() => ({}))
+					.then(({ output }) => {
+						// console.log(output);
+						const outputValue =
+							OperationHandlerResult.getSuccessfulValueOrFail(output);
+						expect(outputValue.success).toEqual(true);
+					})
+					.finallyDoNothing()
+			)
+			.nothingAfterAll()
+	);`.replace(/\s/g, '')).toEqual(result.right.replace(/\s/g, ''));
+    });
+    it('should generate a handler test with a basic object input and output type', () => {
+        const input = {
+            operationNameCamelCase: 'createPerson',
+            input: {
+                type: 'object',
+                properties: {
+                    metadata: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                            },
+                            age: {
+                                type: 'integer',
+                            },
+                        },
+                    },
+                },
+            },
+            output: {
+                type: 'object',
+                properties: {
+                    parents: {
+                        type: 'object',
+                        properties: {
+                            child: {
+                                type: 'string',
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
+        if (E.isLeft(result)) {
+            console.log(result.left);
+            throw new Error('Expected right');
+        }
+        expect(`import { OperationHandlerTestSetup } from '@trayio/cdk-dsl/connector/operation/OperationHandlerTest';
+	import { OperationHandlerResult } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
+	import { createPersonHandler } from './handler';
+	import '@trayio/cdk-runtime/connector/operation/OperationHandlerTestRunner';
+
+	OperationHandlerTestSetup.configureHandlerTest(createPersonHandler, (handlerTest) =>
+		handlerTest
+			.usingHandlerContext('test')
+			.nothingBeforeAll()
+			.testCase('should ${input.operationNameCamelCase}', (testCase) =>
+				testCase
+					.givenNothing()
+					.when(() => ({ metadata: { name: 'test', age: 2 }}))
+					.then(({ output }) => {
+						// console.log(output);
+						const outputValue =
+							OperationHandlerResult.getSuccessfulValueOrFail(output);
+						expect(outputValue.parents).toEqual({child: 'test'});
+					})
+					.finallyDoNothing()
+			)
+			.nothingAfterAll()
+	);`.replace(/\s/g, '')).toEqual(result.right.replace(/\s/g, ''));
+    });
+    it('should generate a handler test with a basic array input and output type', () => {
+        const input = {
+            operationNameCamelCase: 'listItems',
+            input: {
+                type: 'object',
+                properties: {
+                    ids: {
+                        type: 'array',
+                        items: {
+                            type: 'integer',
+                        },
+                    },
+                },
+            },
+            output: {
+                type: 'object',
+                properties: {
+                    parents: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        };
+        const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
+        if (E.isLeft(result)) {
+            console.log(result.left);
+            throw new Error('Expected right');
+        }
+        expect(`import { OperationHandlerTestSetup } from '@trayio/cdk-dsl/connector/operation/OperationHandlerTest';
+	import { OperationHandlerResult } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
+	import { listItemsHandler } from './handler';
+	import '@trayio/cdk-runtime/connector/operation/OperationHandlerTestRunner';
+
+	OperationHandlerTestSetup.configureHandlerTest(listItemsHandler, (handlerTest) =>
+		handlerTest
+			.usingHandlerContext('test')
+			.nothingBeforeAll()
+			.testCase('should ${input.operationNameCamelCase}', (testCase) =>
+				testCase
+					.givenNothing()
+					.when(() => ({ ids: [2] }))
+					.then(({ output }) => {
+						// console.log(output);
+						const outputValue =
+							OperationHandlerResult.getSuccessfulValueOrFail(output);
+						expect(outputValue.parents).toEqual(['test']);
+					})
+					.finallyDoNothing()
+			)
+			.nothingAfterAll()
+	);`.replace(/\s/g, '')).toEqual(result.right.replace(/\s/g, ''));
+    });
+    it('should generate a handler test with a complex object output type', () => {
+        const input = {
+            operationNameCamelCase: 'listItems',
+            input: {},
+            output: {
+                type: 'object',
+                properties: {
+                    parents: {
+                        type: 'object',
+                        properties: {
+                            child: {
+                                type: 'string',
+                            },
+                            valueList: {
+                                type: 'array',
+                                items: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
+        if (E.isLeft(result)) {
+            console.log(result.left);
+            throw new Error('Expected right');
+        }
+        expect(`import { OperationHandlerTestSetup } from '@trayio/cdk-dsl/connector/operation/OperationHandlerTest';
+	import { OperationHandlerResult } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
+	import { listItemsHandler } from './handler';
+	import '@trayio/cdk-runtime/connector/operation/OperationHandlerTestRunner';
+
+	OperationHandlerTestSetup.configureHandlerTest(listItemsHandler, (handlerTest) =>
+		handlerTest
+			.usingHandlerContext('test')
+			.nothingBeforeAll()
+			.testCase('should ${input.operationNameCamelCase}', (testCase) =>
+				testCase
+					.givenNothing()
+					.when(() => ({}))
+					.then(({ output }) => {
+						// console.log(output);
+						const outputValue =
+							OperationHandlerResult.getSuccessfulValueOrFail(output);
+						expect(outputValue.parents).toEqual({child: 'test', valueList: ['test']});
+					})
+					.finallyDoNothing()
+			)
+			.nothingAfterAll()
+	);`.replace(/\s/g, '')).toEqual(result.right.replace(/\s/g, ''));
+    });
+    it('should generate a handler test with a complex array output type', () => {
+        const input = {
+            operationNameCamelCase: 'listItems',
+            input: {},
+            output: {
+                type: 'object',
+                properties: {
+                    parents: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                child: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
+        if (E.isLeft(result)) {
+            console.log(result.left);
+            throw new Error('Expected right');
+        }
+        expect(`import { OperationHandlerTestSetup } from '@trayio/cdk-dsl/connector/operation/OperationHandlerTest';
+	import { OperationHandlerResult } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
+	import { listItemsHandler } from './handler';
+	import '@trayio/cdk-runtime/connector/operation/OperationHandlerTestRunner';
+
+	OperationHandlerTestSetup.configureHandlerTest(listItemsHandler, (handlerTest) =>
+		handlerTest
+			.usingHandlerContext('test')
+			.nothingBeforeAll()
+			.testCase('should ${input.operationNameCamelCase}', (testCase) =>
+				testCase
+					.givenNothing()
+					.when(() => ({}))
+					.then(({ output }) => {
+						// console.log(output);
+						const outputValue =
+							OperationHandlerResult.getSuccessfulValueOrFail(output);
+						expect(outputValue.parents).toEqual([{child: 'test'}]);
+					})
+					.finallyDoNothing()
+			)
+			.nothingAfterAll()
+	);`.replace(/\s/g, '')).toEqual(result.right.replace(/\s/g, ''));
+    });
+});

package/dist/file-generators/GenerateOperationJson.d.ts

@@ -0,0 +1,4 @@
+import * as TE from 'fp-ts/TaskEither';
+import { FileStorage } from '@trayio/commons/file/File';
+export declare const generateOperationJson: (fileStorage: FileStorage, operationDirPath: string, operationNameSnakeCase: string, operationNameKebabCase: string, operationDescription: string) => TE.TaskEither<Error, undefined>;
+//# sourceMappingURL=GenerateOperationJson.d.ts.map

package/dist/file-generators/GenerateOperationJson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerateOperationJson.d.ts","sourceRoot":"","sources":["../../src/file-generators/GenerateOperationJson.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEvC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD,eAAO,MAAM,qBAAqB,gBACpB,WAAW,oBACN,MAAM,0BACA,MAAM,0BACN,MAAM,wBACR,MAAM,KAC1B,GAAG,UAAU,CAAC,KAAK,EAAE,SAAS,CAoBhC,CAAC"}

package/dist/file-generators/GenerateOperationJson.js

@@ -0,0 +1,43 @@
+"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.generateOperationJson = void 0;
+const TE = __importStar(require("fp-ts/TaskEither"));
+const function_1 = require("fp-ts/function");
+const stream_1 = require("stream");
+const generateOperationJson = (fileStorage, operationDirPath, operationNameSnakeCase, operationNameKebabCase, operationDescription) => {
+    const operationJson = {
+        name: operationNameSnakeCase,
+        title: operationNameKebabCase,
+        description: operationDescription,
+    };
+    const writeOperationJson = fileStorage.write({
+        content: stream_1.Readable.from(JSON.stringify(operationJson)),
+        key: `${operationDirPath}/operation.json`,
+        metadata: { name: 'operation.json' },
+    });
+    return (0, function_1.pipe)(writeOperationJson, TE.mapLeft((error) => new Error(`Failed to generate operation.json for operation: ${error}`)), TE.map(() => undefined));
+};
+exports.generateOperationJson = generateOperationJson;

package/dist/file-generators/GenerateOperationJson.test.d.ts

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

package/dist/file-generators/GenerateOperationJson.test.d.ts.map

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

package/dist/file-generators/GenerateOperationJson.test.js

@@ -0,0 +1,77 @@
+"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 E = __importStar(require("fp-ts/Either"));
+const FakeFileStorage_1 = require("@trayio/commons/file/FakeFileStorage");
+const GenerateOperationJson_1 = require("./GenerateOperationJson");
+describe('generateOperationJson', () => {
+    const fileStorage = new FakeFileStorage_1.FakeFileStorage();
+    it('should generate operation.json file', () => __awaiter(void 0, void 0, void 0, function* () {
+        const writeSpy = jest.spyOn(fileStorage, 'write');
+        const operationDirPath = '/path/to/operation';
+        const operationNameSnakeCase = 'get_photo';
+        const operationNameKebabCase = 'get-photo';
+        const operationDescription = 'Get photo operation';
+        const result = yield (0, GenerateOperationJson_1.generateOperationJson)(fileStorage, operationDirPath, operationNameSnakeCase, operationNameKebabCase, operationDescription)();
+        if (E.isLeft(result)) {
+            throw new Error('expected result to be right');
+        }
+        expect(writeSpy).toHaveBeenCalledWith({
+            content: expect.anything(),
+            key: '/path/to/operation/operation.json',
+            metadata: { name: 'operation.json' },
+        });
+        expect(result.right).toBeUndefined();
+        expect(fileStorage.files.has('/path/to/operation/operation.json')).toEqual(true);
+    }));
+    it('should generate correct data for operation.json', () => __awaiter(void 0, void 0, void 0, function* () {
+        const operationDirPath = '/path/to/operation';
+        const operationNameSnakeCase = 'get_photo';
+        const operationNameKebabCase = 'get-photo';
+        const operationDescription = 'Get photo operation';
+        const result = yield (0, GenerateOperationJson_1.generateOperationJson)(fileStorage, operationDirPath, operationNameSnakeCase, operationNameKebabCase, operationDescription)();
+        if (E.isLeft(result)) {
+            throw new Error('expected result to be right');
+        }
+        const operationJson = fileStorage.files.get('/path/to/operation/operation.json');
+        if (operationJson === undefined) {
+            throw new Error('expected operationJson to be defined');
+        }
+        expect(operationJson.content.read()).toEqual(JSON.stringify({
+            name: 'get_photo',
+            title: 'get-photo',
+            description: 'Get photo operation',
+        }));
+    }));
+});

package/dist/file-generators/types/GenerateInputSchema.d.ts

@@ -0,0 +1,4 @@
+import { JSONSchema4 } from 'json-schema';
+import { Path } from '../../OpenApiTypeDescriptors';
+export declare const generateInputSchema: (endpoint: Path) => JSONSchema4;
+//# sourceMappingURL=GenerateInputSchema.d.ts.map

package/dist/file-generators/types/GenerateInputSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerateInputSchema.d.ts","sourceRoot":"","sources":["../../../src/file-generators/types/GenerateInputSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,OAAO,EAAE,IAAI,EAAa,MAAM,8BAA8B,CAAC;AAmE/D,eAAO,MAAM,mBAAmB,aAAc,IAAI,KAAG,WAsBpD,CAAC"}

package/dist/{connector/input/ProcessInput.js → file-generators/types/GenerateInputSchema.js}

@@ -23,11 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processInput = void 0;
+exports.generateInputSchema = void 0;
 const lodash_1 = require("lodash");
 const O = __importStar(require("fp-ts/Option"));
-const GenerateInput_1 = require("./GenerateInput");
-const TransformInput_1 = require("./TransformInput");
+const openapi_schema_to_json_schema_1 = require("@openapi-contrib/openapi-schema-to-json-schema");
 const mergeRequired = (params, body) => {
     if ((0, lodash_1.isArray)(body.required) && (0, lodash_1.isArray)(params.required)) {
         return [...body.required, ...params.required];
@@ -40,6 +39,31 @@ const mergeParamsAndBody = (params, body) => ({
     required: mergeRequired(params, body),
     additionalProperties: false,
 });
+const transformInput = (parameters) => {
+    const transformedParameters = {};
+    const requiredParameters = [];
+    parameters.forEach((parameter) => {
+        const parameterWithJsdocAnnotation = {
+            name: parameter.name,
+            description: `@description ${parameter.description}`,
+            required: parameter.required,
+            schema: {
+                type: parameter.schema.type,
+                format: O.toNullable(parameter.schema.format) || undefined,
+            },
+        };
+        transformedParameters[parameter.name] = Object.assign(Object.assign({}, (0, openapi_schema_to_json_schema_1.fromParameter)(parameterWithJsdocAnnotation)), { in: parameter.in });
+        if (parameter.required === true) {
+            requiredParameters.push(parameter.name);
+        }
+    });
+    return {
+        type: 'object',
+        properties: Object.assign({}, transformedParameters),
+        required: [...requiredParameters],
+        additionalProperties: false,
+    };
+};
 const getApplicationJsonMediaType = (content) => {
     // TODO: we should support any value here, but there may also be more than 1 media type so we need to iterate through
     // and combine all the schemas within into a single set of inputs
@@ -50,17 +74,17 @@ const getApplicationJsonMediaType = (content) => {
     const mediaTypes = Object.keys(content);
     throw new Error(`Unsupported media type: ${mediaTypes}`);
 };
-const extractInput = (endpoint) => {
+const generateInputSchema = (endpoint) => {
     const parameters = O.toNullable(endpoint.parameters);
     const requestBody = O.toNullable(endpoint.requestBody);
     if (parameters && !requestBody) {
-        return (0, TransformInput_1.transformInput)(parameters);
+        return transformInput(parameters);
     }
     if (requestBody && !parameters) {
         return getApplicationJsonMediaType(requestBody.content).schema;
     }
     if (requestBody && parameters) {
-        const params = (0, TransformInput_1.transformInput)(parameters);
+        const params = transformInput(parameters);
         const body = getApplicationJsonMediaType(requestBody.content).schema;
         return mergeParamsAndBody(params, body);
     }
@@ -71,11 +95,4 @@ const extractInput = (endpoint) => {
         additionalProperties: false,
     };
 };
-const processInput = (endpoint) => {
-    const input = extractInput(endpoint);
-    return (0, GenerateInput_1.generateInput)({
-        operationNameCamelCase: endpoint.operationId,
-        parameters: input,
-    });
-};
-exports.processInput = processInput;
+exports.generateInputSchema = generateInputSchema;

package/dist/file-generators/types/GenerateInputSchema.test.d.ts

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

package/dist/file-generators/types/GenerateInputSchema.test.d.ts.map

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