@kevinoid/openapi-transformers 0.1.0

package/urlencoded-to-string.js

@@ -0,0 +1,160 @@
+/**
+ * @copyright Copyright 2020 Kevin Locke <kevin@kevinlocke.name>
+ * @license MIT
+ * @module "openapi-transformers/urlencoded-to-string.js"
+ */
+
+import OpenApiTransformerBase from 'openapi-transformer-base';
+
+const consumesSymbol = Symbol('consumes');
+
+function isFormData(mediaType) {
+  return /^multipart\/form-data\s*(?:;.*)?$/i.test(mediaType);
+}
+
+function isUrlencoded(mediaType) {
+  return /^application\/x-www-form-urlencoded\s*(?:;.*)?$/i.test(mediaType);
+}
+
+/**
+ * Transformer to change request parameter types to string for operations which
+ * only consume application/x-www-form-urlencoded, to work around
+ * https://github.com/Azure/autorest/issues/3449
+ */
+export default class UrlencodedToStringTransformer
+  extends OpenApiTransformerBase {
+  constructor() {
+    super();
+    this[consumesSymbol] = undefined;
+  }
+
+  transformSchema(schema) {
+    if (typeof schema !== 'object' || schema === null) {
+      return schema;
+    }
+
+    let newSchema = super.transformSchema(schema);
+
+    // Change primitive types to string
+    if (['number', 'integer', 'boolean'].includes(schema.type)) {
+      newSchema = {
+        ...newSchema,
+        type: 'string',
+      };
+
+      // TODO: Optionally remove constraints which don't apply to string type?
+      // Older JSON Schema drafts (e.g. JSON Schema Draft 4 ref'd by OAS2)
+      // specify the instance is only valid if it satisfies the constraint.
+      // Newer JSON Schema drafts (e.g. Wright 00 ref'd by OAS3.1) specify
+      // the constraint is ignored for non-numbers.
+      // Autorest ignores these constraints on string properties.
+      // They may be useful as documentation for API developers.
+      // Is there a reason to remove them?
+      /*
+      delete newSchema.multipleOf;
+      delete newSchema.minimum;
+      delete newSchema.exclusiveMaximum;
+      delete newSchema.maximum;
+      delete newSchema.exclusiveMinimum;
+      */
+    }
+
+    // Ensure enums are modeled as string
+    const { type, 'x-ms-enum': xMsEnum } = newSchema;
+    if (type === 'string'
+      && xMsEnum
+      && xMsEnum.modelAsString !== true) {
+      newSchema = { ...newSchema };
+      // Note: Could set modelAsString: true, but would cause conflict if any
+      // other params/schemas have same name
+      delete newSchema['x-ms-enum'];
+    }
+
+    // Note: There does not appear to be a need to remove validation properties
+    // (e.g. minimum, maximum, etc.) since Autorest ignores them for string
+    // properties.
+
+    return newSchema;
+  }
+
+  transformParameter(parameter) {
+    if (!parameter) {
+      return parameter;
+    }
+
+    if (parameter.in === 'formData') {
+      return this.transformSchema(parameter);
+    }
+
+    if (parameter.in === 'body' && parameter.schema) {
+      return {
+        ...parameter,
+        schema: this.transformSchema(parameter.schema),
+      };
+    }
+
+    return parameter;
+  }
+
+  transformRequestBody(requestBody) {
+    if (!requestBody || !requestBody.content) {
+      return requestBody;
+    }
+
+    const { content } = requestBody;
+    const consumes = Object.keys(content);
+    const urlencoded = consumes.find(isUrlencoded);
+    if (!urlencoded) {
+      return requestBody;
+    }
+
+    return {
+      ...requestBody,
+      content: {
+        ...content,
+        [urlencoded]: this.transformMediaType(content[urlencoded]),
+      },
+    };
+  }
+
+  transformOperation(operation) {
+    if (!operation) {
+      return super.transformOperation(operation);
+    }
+
+    const { parameters, requestBody } = operation;
+    if (requestBody === undefined && !Array.isArray(parameters)) {
+      return operation;
+    }
+
+    const newOperation = { ...operation };
+
+    const consumes = operation.consumes || this[consumesSymbol];
+    if (parameters !== undefined
+      && Array.isArray(consumes)
+      && consumes.some(isUrlencoded)
+      && !consumes.some(isFormData)) {
+      newOperation.parameters =
+        parameters.map(this.transformParameter.bind(this));
+    }
+
+    if (requestBody !== undefined) {
+      newOperation.requestBody =
+        this.transformRequestBody(newOperation.requestBody);
+    }
+
+    return newOperation;
+  }
+
+  transformOpenApi(openApi) {
+    this[consumesSymbol] = openApi.consumes;
+    try {
+      return {
+        ...openApi,
+        paths: this.transformPaths(openApi.paths),
+      };
+    } finally {
+      this[consumesSymbol] = undefined;
+    }
+  }
+}

package/x-enum-to-ms.js

@@ -0,0 +1,92 @@
+/**
+ * @copyright Copyright 2019 Kevin Locke <kevin@kevinlocke.name>
+ * @license MIT
+ * @module "openapi-transformers/x-enum-to-ms.js"
+ */
+
+import { debuglog } from 'node:util';
+
+import OpenApiTransformerBase from 'openapi-transformer-base';
+
+const debug = debuglog('x-enum-to-ms');
+
+function transformSchemaXEnumToXMsEnum(schema, schemaName) {
+  if ((!schema['x-enum-descriptions'] && !schema['x-enum-varnames'])
+    || (schema['x-ms-enum'] && schema['x-ms-enum'].values)) {
+    // Schema doesn't have enum varnames/descriptions to convert,
+    // or already has x-ms-enum.values
+    return schema;
+  }
+
+  const {
+    'x-enum-descriptions': descriptions,
+    'x-enum-varnames': varnames,
+    ...newSchema
+  } = schema;
+
+  const xMsEnum = {
+    // Make name first in output for aesthetics
+    name: undefined,
+    ...newSchema['x-ms-enum'],
+    values: newSchema.enum.map((value, i) => ({
+      value,
+      description: descriptions ? descriptions[i] : undefined,
+      name: varnames ? varnames[i] : undefined,
+    })),
+  };
+
+  if (!xMsEnum.name) {
+    if (!schemaName) {
+      debug('Unable to determine required x-ms-enum.name for %O', schema);
+      return schema;
+    }
+
+    xMsEnum.name = schemaName;
+  }
+
+  newSchema['x-ms-enum'] = xMsEnum;
+  return newSchema;
+}
+
+/**
+ * Transformer to convert x-enum-descriptions and x-enum-varnames to x-ms-enum
+ * for Autorest.
+ *
+ * https://github.com/OpenAPITools/openapi-generator/blob/master/docs/templating.md#enum
+ * https://github.com/Azure/autorest/tree/master/docs/extensions#x-ms-enum
+ */
+export default class XEnumToXMsEnumTransformer extends OpenApiTransformerBase {
+  transformSchema(schema, schemaName) {
+    return transformSchemaXEnumToXMsEnum(
+      super.transformSchema(schema),
+      schemaName,
+    );
+  }
+
+  // Override to pass schemaName as second argument to transformSchema
+  transformMap(obj, transform) {
+    if (transform !== this.transformSchema) {
+      return super.transformMap(obj, transform);
+    }
+
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+      return obj;
+    }
+
+    const newObj = { ...obj };
+    for (const [propName, propValue] of Object.entries(obj)) {
+      if (propValue !== undefined) {
+        newObj[propName] = transform.call(this, propValue, propName);
+      }
+    }
+
+    return newObj;
+  }
+
+  transformParameter(parameter) {
+    return transformSchemaXEnumToXMsEnum(
+      super.transformParameter(parameter),
+      undefined,
+    );
+  }
+}