oas 20.9.0 → 20.10.1

package/dist/lib/openapi-to-json-schema.d.ts

@@ -25,7 +25,7 @@ export interface toJSONSchemaOptions {
      */
     isPolymorphicAllOfChild?: boolean;
     /**
-     * Array of parent `default` schemas to utilzie when attempting to path together schema defaults.
+     * Array of parent `default` schemas to utilize when attempting to path together schema defaults.
      */
     prevDefaultSchemas?: RMOAS.SchemaObject[];
     /**

package/dist/lib/openapi-to-json-schema.js

@@ -363,6 +363,12 @@ function toJSONSchema(data, opts) {
                     else {
                         schema[polyType][idx] = toJSONSchema(item, polyOptions);
                     }
+                    // Ensure that we don't have any invalid `required` booleans lying around.
+                    if ((0, helpers_1.isObject)(schema[polyType][idx]) &&
+                        'required' in schema[polyType][idx] &&
+                        typeof schema[polyType][idx].required === 'boolean') {
+                        delete schema[polyType][idx].required;
+                    }
                 });
             }
         });
@@ -599,6 +605,12 @@ function toJSONSchema(data, opts) {
                         refLogger: refLogger,
                         transformer: transformer,
                     });
+                    // If we have a non-array `required` entry in our `items` schema then it's invalid and we
+                    // should remove it. We only support non-array boolean `required` properties inside object
+                    // properties.
+                    if ((0, helpers_1.isObject)(schema.items) && 'required' in schema.items && !Array.isArray(schema.items.required)) {
+                        delete schema.items.required;
+                    }
                 }
             }
             else if ('properties' in schema || 'additionalProperties' in schema) {
@@ -631,19 +643,39 @@ function toJSONSchema(data, opts) {
                             transformer: transformer,
                         });
                         // If this property is read or write only then we should fully hide it from its parent schema.
+                        var propShouldBeUpdated = true;
                         if ((hideReadOnlyProperties || hideWriteOnlyProperties) && !Object.keys(newPropSchema).length) {
                             // We should only delete this schema if it wasn't already empty though. We do this
                             // because we (un)fortunately have handling in our API Explorer form system for
                             // schemas that are devoid of any `type` declaration.
                             if (Object.keys(schema.properties[prop]).length > 0) {
                                 delete schema.properties[prop];
-                            }
-                            else {
-                                schema.properties[prop] = newPropSchema;
+                                propShouldBeUpdated = false;
                             }
                         }
-                        else {
+                        if (propShouldBeUpdated) {
                             schema.properties[prop] = newPropSchema;
+                            /**
+                             * JSON Schema does not have any support for `required: <boolean>` but because some
+                             * of our users do this, and it does not throw OpenAPI validation errors thanks to
+                             * some extremely loose typings around `schema` in the official JSON Schema
+                             * definitions that the OAI offers, we're opting to support these users and upgrade
+                             * their invalid `required` definitions into ones that our tooling can interpret.
+                             *
+                             * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/schemas/v3.1/schema.json#L1114-L1121}
+                             */
+                            if ((0, helpers_1.isObject)(newPropSchema) &&
+                                'required' in newPropSchema &&
+                                typeof newPropSchema.required === 'boolean' &&
+                                newPropSchema.required === true) {
+                                if ('required' in schema && Array.isArray(schema.required)) {
+                                    schema.required.push(prop);
+                                }
+                                else {
+                                    schema.required = [prop];
+                                }
+                                delete schema.properties[prop].required;
+                            }
                         }
                     }
                 });

package/dist/operation/get-parameters-as-json-schema.js

@@ -169,28 +169,12 @@ function getParametersAsJSONSchema(operation, api, opts) {
         if (!('components' in api)) {
             return false;
         }
-        var components = {
-            /**
-             * Initializing an empty `components[componentType] = {}` object within the `forEach` below
-             * is incredibly slow because each of these component types has a wide variety of shapes. So
-             * in order to not have TS compilation times that takes literally **seconds** because of a
-             * single line we're instead opting to prefill this object with some empty placeholders that
-             * we'll later remove if they didn't get used.
-             *
-             * Obviously not ideal but I'd rather have a couple lines of boilerplate nonsense than having
-             * to wait a noticeably frustrating amount of time for TS Intellisense to reload itself after
-             * you save a line in any file.
-             */
-            examples: {},
-            schemas: {},
-            responses: {},
-            parameters: {},
-            requestBodies: {},
-            headers: {},
-            securitySchemes: {},
-            links: {},
-            callbacks: {},
-        };
+        var components = __assign({}, Object.keys(api.components)
+            .map(function (componentType) {
+            var _a;
+            return (_a = {}, _a[componentType] = {}, _a);
+        })
+            .reduce(function (prev, next) { return Object.assign(prev, next); }, {}));
         Object.keys(api.components).forEach(function (componentType) {
             if (typeof api.components[componentType] === 'object' && !Array.isArray(api.components[componentType])) {
                 Object.keys(api.components[componentType]).forEach(function (schemaName) {
@@ -206,17 +190,7 @@ function getParametersAsJSONSchema(operation, api, opts) {
             }
         });
         // If none of our above component type placeholders got used let's clean them up.
-        [
-            'examples',
-            'schemas',
-            'responses',
-            'parameters',
-            'requestBodies',
-            'headers',
-            'securitySchemes',
-            'links',
-            'callbacks',
-        ].forEach(function (componentType) {
+        Object.keys(components).forEach(function (componentType) {
             if (!Object.keys(components[componentType]).length) {
                 delete components[componentType];
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oas",
-  "version": "20.9.0",
+  "version": "20.10.1",
   "description": "Comprehensive tooling for working with OpenAPI definitions",
   "license": "MIT",
   "author": "ReadMe <support@readme.io> (https://readme.com)",

package/src/lib/openapi-to-json-schema.ts

@@ -57,7 +57,7 @@ export interface toJSONSchemaOptions {
   isPolymorphicAllOfChild?: boolean;
 
   /**
-   * Array of parent `default` schemas to utilzie when attempting to path together schema defaults.
+   * Array of parent `default` schemas to utilize when attempting to path together schema defaults.
    */
   prevDefaultSchemas?: RMOAS.SchemaObject[];
 
@@ -431,6 +431,15 @@ export default function toJSONSchema(
           } else {
             schema[polyType][idx] = toJSONSchema(item as RMOAS.SchemaObject, polyOptions);
           }
+
+          // Ensure that we don't have any invalid `required` booleans lying around.
+          if (
+            isObject(schema[polyType][idx]) &&
+            'required' in (schema[polyType][idx] as SchemaObject) &&
+            typeof (schema[polyType][idx] as SchemaObject).required === 'boolean'
+          ) {
+            delete (schema[polyType][idx] as SchemaObject).required;
+          }
         });
       }
     });
@@ -674,6 +683,13 @@ export default function toJSONSchema(
             refLogger,
             transformer,
           });
+
+          // If we have a non-array `required` entry in our `items` schema then it's invalid and we
+          // should remove it. We only support non-array boolean `required` properties inside object
+          // properties.
+          if (isObject(schema.items) && 'required' in schema.items && !Array.isArray(schema.items.required)) {
+            delete schema.items.required;
+          }
         }
       } else if ('properties' in schema || 'additionalProperties' in schema) {
         // This is a fix to handle cases where someone may have typod `items` as `properties` on an
@@ -706,17 +722,43 @@ export default function toJSONSchema(
             });
 
             // If this property is read or write only then we should fully hide it from its parent schema.
+            let propShouldBeUpdated = true;
             if ((hideReadOnlyProperties || hideWriteOnlyProperties) && !Object.keys(newPropSchema).length) {
               // We should only delete this schema if it wasn't already empty though. We do this
               // because we (un)fortunately have handling in our API Explorer form system for
               // schemas that are devoid of any `type` declaration.
               if (Object.keys(schema.properties[prop]).length > 0) {
                 delete schema.properties[prop];
-              } else {
-                schema.properties[prop] = newPropSchema;
+                propShouldBeUpdated = false;
               }
-            } else {
+            }
+
+            if (propShouldBeUpdated) {
               schema.properties[prop] = newPropSchema;
+
+              /**
+               * JSON Schema does not have any support for `required: <boolean>` but because some
+               * of our users do this, and it does not throw OpenAPI validation errors thanks to
+               * some extremely loose typings around `schema` in the official JSON Schema
+               * definitions that the OAI offers, we're opting to support these users and upgrade
+               * their invalid `required` definitions into ones that our tooling can interpret.
+               *
+               * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/schemas/v3.1/schema.json#L1114-L1121}
+               */
+              if (
+                isObject(newPropSchema) &&
+                'required' in newPropSchema &&
+                typeof newPropSchema.required === 'boolean' &&
+                newPropSchema.required === true
+              ) {
+                if ('required' in schema && Array.isArray(schema.required)) {
+                  schema.required.push(prop);
+                } else {
+                  schema.required = [prop];
+                }
+
+                delete (schema.properties[prop] as SchemaObject).required;
+              }
             }
           }
         });

package/src/operation/get-parameters-as-json-schema.ts

@@ -220,26 +220,9 @@ export default function getParametersAsJSONSchema(
     }
 
     const components: Partial<ComponentsObject> = {
-      /**
-       * Initializing an empty `components[componentType] = {}` object within the `forEach` below
-       * is incredibly slow because each of these component types has a wide variety of shapes. So
-       * in order to not have TS compilation times that takes literally **seconds** because of a
-       * single line we're instead opting to prefill this object with some empty placeholders that
-       * we'll later remove if they didn't get used.
-       *
-       * Obviously not ideal but I'd rather have a couple lines of boilerplate nonsense than having
-       * to wait a noticeably frustrating amount of time for TS Intellisense to reload itself after
-       * you save a line in any file.
-       */
-      examples: {},
-      schemas: {},
-      responses: {},
-      parameters: {},
-      requestBodies: {},
-      headers: {},
-      securitySchemes: {},
-      links: {},
-      callbacks: {},
+      ...Object.keys(api.components)
+        .map(componentType => ({ [componentType]: {} }))
+        .reduce((prev, next) => Object.assign(prev, next), {}),
     };
 
     Object.keys(api.components).forEach((componentType: keyof ComponentsObject) => {
@@ -258,17 +241,7 @@ export default function getParametersAsJSONSchema(
     });
 
     // If none of our above component type placeholders got used let's clean them up.
-    [
-      'examples',
-      'schemas',
-      'responses',
-      'parameters',
-      'requestBodies',
-      'headers',
-      'securitySchemes',
-      'links',
-      'callbacks',
-    ].forEach((componentType: keyof ComponentsObject) => {
+    Object.keys(components).forEach((componentType: keyof ComponentsObject) => {
       if (!Object.keys(components[componentType]).length) {
         delete components[componentType];
       }