@trayio/tray-openapi 2.9.0 → 2.10.0

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

@@ -24,38 +24,81 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const E = __importStar(require("fp-ts/Either"));
+const O = __importStar(require("fp-ts/Option"));
 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: {
+                type: O.some('object'),
+                properties: O.some({
                     id: {
-                        type: 'integer',
+                        type: O.some('integer'),
                         format: 'int64',
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
                     name: {
-                        type: 'string',
+                        type: O.some('string'),
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
-                required: ['id', 'name'],
-                additionalProperties: false,
+                }),
+                required: O.some(['id', 'name']),
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
             output: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     id: {
-                        type: 'integer',
+                        type: O.some('integer'),
                         format: 'int64',
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
                     name: {
-                        type: 'string',
+                        type: O.some('string'),
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
-                required: ['id'],
-                additionalProperties: false,
+                }),
+                required: O.some(['id']),
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
         };
         const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
@@ -91,16 +134,39 @@ describe('GenerateHandlerTest', () => {
     it('should generate a handler test with empty inputs', () => {
         const input = {
             operationNameCamelCase: 'getItem',
-            input: {},
+            input: {
+                type: O.none,
+                properties: O.none,
+                required: O.none,
+                additionalProperties: O.none,
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
+            },
             output: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     success: {
-                        type: 'boolean',
+                        type: O.some('boolean'),
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.none,
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
-                required: ['success'],
-                additionalProperties: false,
+                }),
+                required: O.some(['success']),
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
         };
         const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
@@ -136,33 +202,85 @@ describe('GenerateHandlerTest', () => {
         const input = {
             operationNameCamelCase: 'createPerson',
             input: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     metadata: {
-                        type: 'object',
-                        properties: {
+                        type: O.some('object'),
+                        properties: O.some({
                             name: {
-                                type: 'string',
+                                type: O.some('string'),
+                                properties: O.none,
+                                required: O.none,
+                                additionalProperties: O.some(false),
+                                allOf: O.none,
+                                anyOf: O.none,
+                                oneOf: O.none,
+                                not: O.none,
+                                in: O.none,
                             },
                             age: {
-                                type: 'integer',
+                                type: O.some('integer'),
+                                properties: O.none,
+                                required: O.none,
+                                additionalProperties: O.some(false),
+                                allOf: O.none,
+                                anyOf: O.none,
+                                oneOf: O.none,
+                                not: O.none,
+                                in: O.none,
                             },
-                        },
+                        }),
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
+                }),
+                required: O.none,
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
             output: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     parents: {
-                        type: 'object',
-                        properties: {
+                        type: O.some('object'),
+                        properties: O.some({
                             child: {
-                                type: 'string',
+                                type: O.some('string'),
+                                properties: O.none,
+                                required: O.none,
+                                additionalProperties: O.some(false),
+                                allOf: O.none,
+                                anyOf: O.none,
+                                oneOf: O.none,
+                                not: O.none,
+                                in: O.none,
                             },
-                        },
+                        }),
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
+                }),
+                required: O.none,
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
         };
         const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
@@ -198,26 +316,72 @@ describe('GenerateHandlerTest', () => {
         const input = {
             operationNameCamelCase: 'listItems',
             input: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     ids: {
                         type: 'array',
                         items: {
-                            type: 'integer',
+                            type: O.some('integer'),
+                            properties: O.none,
+                            required: O.none,
+                            additionalProperties: O.some(false),
+                            allOf: O.none,
+                            anyOf: O.none,
+                            oneOf: O.none,
+                            not: O.none,
+                            in: O.none,
                         },
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
+                }),
+                required: O.none,
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
             output: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     parents: {
                         type: 'array',
                         items: {
-                            type: 'string',
+                            type: O.some('string'),
+                            properties: O.none,
+                            required: O.none,
+                            additionalProperties: O.some(false),
+                            allOf: O.none,
+                            anyOf: O.none,
+                            oneOf: O.none,
+                            not: O.none,
+                            in: O.none,
                         },
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
+                }),
+                required: O.none,
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
         };
         const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
@@ -252,25 +416,73 @@ describe('GenerateHandlerTest', () => {
     it('should generate a handler test with a complex object output type', () => {
         const input = {
             operationNameCamelCase: 'listItems',
-            input: {},
+            input: {
+                type: O.none,
+                properties: O.none,
+                required: O.none,
+                additionalProperties: O.none,
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
+            },
             output: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     parents: {
-                        type: 'object',
-                        properties: {
+                        type: O.some('object'),
+                        properties: O.some({
                             child: {
-                                type: 'string',
+                                type: O.some('string'),
+                                properties: O.none,
+                                required: O.none,
+                                additionalProperties: O.none,
+                                allOf: O.none,
+                                anyOf: O.none,
+                                oneOf: O.none,
+                                not: O.none,
+                                in: O.none,
                             },
                             valueList: {
                                 type: 'array',
                                 items: {
-                                    type: 'string',
+                                    type: O.some('string'),
+                                    properties: O.none,
+                                    required: O.none,
+                                    additionalProperties: O.none,
+                                    allOf: O.none,
+                                    anyOf: O.none,
+                                    oneOf: O.none,
+                                    not: O.none,
+                                    in: O.none,
                                 },
+                                properties: O.none,
+                                required: O.none,
+                                additionalProperties: O.some(false),
+                                allOf: O.none,
+                                anyOf: O.none,
+                                oneOf: O.none,
+                                not: O.none,
+                                in: O.none,
                             },
-                        },
+                        }),
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
+                }),
+                required: O.none,
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
         };
         const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);
@@ -305,22 +517,62 @@ describe('GenerateHandlerTest', () => {
     it('should generate a handler test with a complex array output type', () => {
         const input = {
             operationNameCamelCase: 'listItems',
-            input: {},
+            input: {
+                type: O.none,
+                properties: O.none,
+                required: O.none,
+                additionalProperties: O.none,
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
+            },
             output: {
-                type: 'object',
-                properties: {
+                type: O.some('object'),
+                properties: O.some({
                     parents: {
                         type: 'array',
                         items: {
-                            type: 'object',
-                            properties: {
+                            type: O.some('object'),
+                            properties: O.some({
                                 child: {
-                                    type: 'string',
+                                    type: O.some('string'),
+                                    properties: O.none,
+                                    required: O.none,
+                                    additionalProperties: O.none,
+                                    allOf: O.none,
+                                    anyOf: O.none,
+                                    oneOf: O.none,
+                                    not: O.none,
+                                    in: O.none,
                                 },
-                            },
+                            }),
+                            required: O.none,
+                            additionalProperties: O.none,
+                            allOf: O.none,
+                            anyOf: O.none,
+                            oneOf: O.none,
+                            not: O.none,
+                            in: O.none,
                         },
+                        properties: O.none,
+                        required: O.none,
+                        additionalProperties: O.some(false),
+                        allOf: O.none,
+                        anyOf: O.none,
+                        oneOf: O.none,
+                        not: O.none,
+                        in: O.none,
                     },
-                },
+                }),
+                required: O.none,
+                additionalProperties: O.some(false),
+                allOf: O.none,
+                anyOf: O.none,
+                oneOf: O.none,
+                not: O.none,
+                in: O.none,
             },
         };
         const result = (0, GenerateHandlerTest_1.generateHandlerTest)(input);

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

@@ -34,6 +34,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const E = __importStar(require("fp-ts/Either"));
 const FakeFileStorage_1 = require("@trayio/commons/file/FakeFileStorage");
+const O = __importStar(require("fp-ts/Option"));
 const GenerateOperationJson_1 = require("./GenerateOperationJson");
 describe('generateOperationJson', () => {
     const fileStorage = new FakeFileStorage_1.FakeFileStorage();
@@ -51,7 +52,7 @@ describe('generateOperationJson', () => {
             content: expect.anything(),
             key: '/path/to/operation/operation.json',
             metadata: { name: 'operation.json' },
-        });
+        }, O.none);
         expect(result.right).toBeUndefined();
         expect(fileStorage.files.has('/path/to/operation/operation.json')).toEqual(true);
     }));

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

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

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

@@ -1 +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"}
+{"version":3,"file":"GenerateInputSchema.d.ts","sourceRoot":"","sources":["../../../src/file-generators/types/GenerateInputSchema.ts"],"names":[],"mappings":"AAMA,OAAO,EACN,IAAI,EAGJ,YAAY,EAEZ,MAAM,8BAA8B,CAAC;AA8HtC,eAAO,MAAM,mBAAmB,aAAc,IAAI,KAAG,YAiCpD,CAAC"}

package/dist/file-generators/types/GenerateInputSchema.js

@@ -27,72 +27,107 @@ exports.generateInputSchema = void 0;
 const lodash_1 = require("lodash");
 const O = __importStar(require("fp-ts/Option"));
 const openapi_schema_to_json_schema_1 = require("@openapi-contrib/openapi-schema-to-json-schema");
+const CompositeCodec_1 = require("@trayio/commons/codec/CompositeCodec");
+const RemoveNullValuesCodec_1 = require("@trayio/commons/codec/RemoveNullValuesCodec");
+const OpenApiCodecs_1 = require("../../OpenApiCodecs");
+const OpenApiTypeDescriptors_1 = require("../../OpenApiTypeDescriptors");
 const mergeRequired = (params, body) => {
-    if ((0, lodash_1.isArray)(body.required) && (0, lodash_1.isArray)(params.required)) {
-        return [...body.required, ...params.required];
+    const requiredBody = O.fold(() => [], (required) => required)(body.required);
+    const requiredParams = O.fold(() => [], (required) => required)(params.required);
+    if ((0, lodash_1.isArray)(requiredBody) && (0, lodash_1.isArray)(requiredParams)) {
+        return [...requiredBody, ...requiredParams];
     }
     return [];
 };
 const mergeParamsAndBody = (params, body) => ({
-    type: 'object',
-    properties: Object.assign(Object.assign({}, body.properties), params.properties),
-    required: mergeRequired(params, body),
-    additionalProperties: false,
+    type: O.some('object'),
+    properties: O.some(Object.assign(Object.assign({}, (O.isSome(body.properties) && body.properties.value)), (O.isSome(params.properties) && params.properties.value))),
+    required: O.some(mergeRequired(params, body)),
+    additionalProperties: O.some(false),
+    allOf: O.none,
+    anyOf: O.none,
+    oneOf: O.none,
+    not: O.none,
+    in: O.none,
 });
 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 });
+        const codecWithNullValueRemoval = CompositeCodec_1.CompositeCodec.fromCodecs(OpenApiCodecs_1.parameterSchemaCodec, RemoveNullValuesCodec_1.RemoveNullValuesCodec.instance);
+        const parameterWithNoOptions = codecWithNullValueRemoval.encode(parameter);
+        const parameterWithJsdocAnnotation = Object.assign(Object.assign({}, parameterWithNoOptions), { description: `@description ${parameter.description}` });
+        const decodedParam = OpenApiTypeDescriptors_1.schemaObjectTypeDescriptor.decode(Object.assign(Object.assign({}, (0, openapi_schema_to_json_schema_1.fromParameter)(parameterWithJsdocAnnotation)), { in: parameter.in }));
+        if (decodedParam._tag === 'Left') {
+            throw new Error('Failed to decode params');
+        }
+        transformedParameters[parameter.name] = decodedParam.right;
         if (parameter.required === true) {
             requiredParameters.push(parameter.name);
         }
     });
     return {
-        type: 'object',
-        properties: Object.assign({}, transformedParameters),
-        required: [...requiredParameters],
-        additionalProperties: false,
+        type: O.some('object'),
+        properties: O.some(transformedParameters),
+        required: O.some([...requiredParameters]),
+        additionalProperties: O.some(false),
+        allOf: O.none,
+        anyOf: O.none,
+        oneOf: O.none,
+        not: O.none,
+        in: O.none,
     };
 };
+/**
+ * OpenAPI spec's body params don't have an .in property, we add one in here since query, path, and header params do
+ */
+const appendInPropertyToBody = (body) => O.fold(() => body, (properties) => {
+    const propsWithInBody = Object.keys(properties).reduce((acc, name) => (Object.assign(Object.assign({}, acc), { [name]: Object.assign(Object.assign({}, properties[name]), { in: O.some('body') }) })), {});
+    return Object.assign(Object.assign({}, body), { properties: O.some(propsWithInBody) });
+})(body.properties);
 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
     const mediaTypeApplicationJson = Object.keys(content).find((mediaType) => /^application\/.*json$/.test(mediaType));
+    // TODO: fold here instead of getOrElse
     if (mediaTypeApplicationJson) {
-        return content[mediaTypeApplicationJson];
+        return O.getOrElse(() => {
+            throw new Error('');
+        })(content[mediaTypeApplicationJson].schema);
     }
     const mediaTypes = Object.keys(content);
     throw new Error(`Unsupported media type: ${mediaTypes}`);
 };
 const generateInputSchema = (endpoint) => {
+    // TODO: use the encode method instead of this, or fold over the values
     const parameters = O.toNullable(endpoint.parameters);
     const requestBody = O.toNullable(endpoint.requestBody);
     if (parameters && !requestBody) {
         return transformInput(parameters);
     }
     if (requestBody && !parameters) {
-        return getApplicationJsonMediaType(requestBody.content).schema;
+        // TODO: update all uses to this now that getAppJsonMedia doesn't do get content within it? return getApplicationJsonMediaType(getContent(requestBody.content));
+        const body = getApplicationJsonMediaType(requestBody.content);
+        return appendInPropertyToBody(body);
+        // return getApplicationJsonMediaType(getContent(requestBody.content));
     }
     if (requestBody && parameters) {
         const params = transformInput(parameters);
-        const body = getApplicationJsonMediaType(requestBody.content).schema;
-        return mergeParamsAndBody(params, body);
+        const body = getApplicationJsonMediaType(requestBody.content);
+        const bodyWithInProperty = appendInPropertyToBody(body);
+        const mergedParamsAndBody = mergeParamsAndBody(params, bodyWithInProperty);
+        return mergedParamsAndBody;
     }
     return {
-        type: 'object',
-        properties: {},
-        required: [],
-        additionalProperties: false,
+        type: O.none,
+        properties: O.none,
+        required: O.none,
+        additionalProperties: O.some(false),
+        allOf: O.none,
+        anyOf: O.none,
+        oneOf: O.none,
+        not: O.none,
+        in: O.none,
     };
 };
 exports.generateInputSchema = generateInputSchema;