feat(oas): support application/x-www-form-urlencoded OAS style serialization

packages/oas/src/converter/parts/postdata/BodyConverter.ts

@@ -2,7 +2,6 @@ import type { Sampler } from '../../Sampler';
 import type { SubConverter } from '../../SubConverter';
 import { XmlSerializer } from '../../serializers';
 import type { OpenAPI, OpenAPIV2, OpenAPIV3, PostData } from '@har-sdk/core';
-import { stringify } from 'qs';
 
 export interface EncodingData {
   value: unknown;
@@ -38,6 +37,12 @@ export abstract class BodyConverter<T extends OpenAPI.Document>
     method: string
   ): string | undefined;
 
+  protected abstract encodeFormUrlencoded(
+    value: unknown,
+    fields?: Record<string, OpenAPIV3.EncodingObject>,
+    schema?: OpenAPIV3.SchemaObject | OpenAPIV2.SchemaObject
+  ): string;
+
   protected encodePayload({ contentType, ...options }: EncodingData): PostData {
     return {
       mimeType: contentType.includes('multipart')
@@ -70,7 +75,7 @@ export abstract class BodyConverter<T extends OpenAPI.Document>
       case 'application/json':
         return this.encodeJson(value);
       case 'application/x-www-form-urlencoded':
-        return this.encodeFormUrlencoded(value);
+        return this.encodeFormUrlencoded(value, fields, schema);
       case 'application/xml':
       case 'text/xml':
       case 'application/atom+xml':
@@ -188,14 +193,6 @@ export abstract class BodyConverter<T extends OpenAPI.Document>
     return typeof value === 'string' ? value : JSON.stringify(value);
   }
 
-  // TODO: we should take into account the the Encoding Object's style property (OAS3)
-  private encodeFormUrlencoded(value: unknown): string {
-    return stringify(value, {
-      format: 'RFC3986',
-      encode: false
-    });
-  }
-
   private encodeXml(
     data: unknown,
     schema: OpenAPIV3.SchemaObject | OpenAPIV2.SchemaObject

packages/oas/src/converter/parts/postdata/Oas2BodyConverter.ts

@@ -3,6 +3,8 @@ import type { Sampler } from '../../Sampler';
 import { filterLocationParams, getParameters } from '../../../utils';
 import { Oas2MediaTypesResolver } from '../Oas2MediaTypesResolver';
 import type { OpenAPIV2, PostData } from '@har-sdk/core';
+import { OpenAPIV3 } from '@har-sdk/core';
+import { stringify } from 'qs';
 
 export class Oas2BodyConverter extends BodyConverter<OpenAPIV2.Document> {
   private readonly oas2MediaTypeResolver: Oas2MediaTypesResolver;
@@ -45,6 +47,17 @@ export class Oas2BodyConverter extends BodyConverter<OpenAPIV2.Document> {
     });
   }
 
+  protected encodeFormUrlencoded(
+    value: unknown,
+    _fields?: Record<string, OpenAPIV3.EncodingObject>,
+    _schema?: OpenAPIV3.SchemaObject | OpenAPIV2.SchemaObject
+  ): string {
+    return stringify(value, {
+      format: 'RFC3986',
+      encode: false
+    });
+  }
+
   private convertFormData(
     params: OpenAPIV2.ParameterObject[],
     {

packages/oas/src/converter/parts/postdata/Oas3RequestBodyConverter.ts

@@ -1,9 +1,12 @@
 import { BodyConverter } from './BodyConverter';
 import type { Sampler } from '../../Sampler';
+import { FormUrlEncodedMediaTypeEncoder } from './encoders/FormUrlEncodedMediaTypeEncoder';
 import type { OpenAPIV3, PostData } from '@har-sdk/core';
+import { OpenAPIV2 } from '@har-sdk/core';
 import pointer from 'json-pointer';
 
 export class Oas3RequestBodyConverter extends BodyConverter<OpenAPIV3.Document> {
+  private readonly formUrlEncodedEncoder = new FormUrlEncodedMediaTypeEncoder();
   constructor(spec: OpenAPIV3.Document, sampler: Sampler) {
     super(spec, sampler);
   }
@@ -43,6 +46,18 @@ export class Oas3RequestBodyConverter extends BodyConverter<OpenAPIV3.Document>
     });
   }
 
+  protected encodeFormUrlencoded(
+    value: unknown,
+    fields?: Record<string, OpenAPIV3.EncodingObject>,
+    schema?: OpenAPIV3.SchemaObject | OpenAPIV2.SchemaObject
+  ): string {
+    return this.formUrlEncodedEncoder.encode({
+      fields,
+      value,
+      schema
+    });
+  }
+
   private sampleAndEncodeRequestBody({
     media,
     tokens,
@@ -84,13 +99,15 @@ export class Oas3RequestBodyConverter extends BodyConverter<OpenAPIV3.Document>
       Object.entries(mediaType.encoding ?? {}).map(
         ([property, encoding]: [string, OpenAPIV3.EncodingObject]) => [
           property,
-          this.encodeValue({
-            value: data[property],
-            contentType: encoding.contentType,
-            schema: (mediaType.schema as OpenAPIV3.SchemaObject).properties[
-              property
-            ]
-          })
+          encoding.contentType
+            ? this.encodeValue({
+                value: data[property],
+                contentType: encoding.contentType,
+                schema: (mediaType.schema as OpenAPIV3.SchemaObject).properties[
+                  property
+                ]
+              })
+            : data[property]
         ]
       )
     );

packages/oas/src/converter/parts/postdata/encoders/FormUrlEncodedMediaTypeEncoder.ts

@@ -0,0 +1,76 @@
+import {
+  OasStyleSerializer,
+  OasStyleSerializerType
+} from '../style-serializers/OasStyleSerializer';
+import { isObject } from '../../../../utils';
+import { isPrimitive } from '../../../../utils/isPrimitive';
+import { isArrayOfPrimitives } from '../../../../utils/isArrayOfPrimitives';
+import { OasDeepObjectStyleSerializer } from '../style-serializers/OasDeepObjectStyleSerializer';
+import { OasDefaultStylesSerializer } from '../style-serializers/OasDefaultStylesSerializer';
+import { OpenAPIV2, type OpenAPIV3 } from '@har-sdk/core';
+
+export class FormUrlEncodedMediaTypeEncoder {
+  constructor(
+    private readonly oasStyleSerializers: OasStyleSerializer[] = [
+      new OasDeepObjectStyleSerializer(),
+      new OasDefaultStylesSerializer()
+    ]
+  ) {}
+
+  public encode(encodingData: {
+    value: unknown;
+    fields?: Record<string, OpenAPIV3.EncodingObject>;
+    schema?: OpenAPIV3.SchemaObject | OpenAPIV2.SchemaObject;
+  }): string {
+    const { value, fields } = encodingData;
+
+    if (!isObject(value) || Array.isArray(value)) {
+      return '';
+    }
+
+    const entries = Object.entries(value)
+      .map(([key, val]: [string, unknown]) => {
+        const serializationParams = this.getSerializationParams(
+          (fields ? fields[key] : undefined) ?? {}
+        );
+
+        const { style, explode, allowReserved } = serializationParams;
+
+        const stringifyObject =
+          style === OasStyleSerializerType.FORM &&
+          !(isPrimitive(val) || isArrayOfPrimitives(val));
+
+        return this.findSerializer(style)?.serialize(
+          {
+            key,
+            value: stringifyObject ? JSON.stringify(val) : val
+          },
+          { allowReserved, explode, style }
+        );
+      })
+      .filter(Boolean);
+
+    return entries.join('&');
+  }
+
+  private findSerializer(style: OasStyleSerializerType) {
+    return this.oasStyleSerializers
+      .filter((x) => x.supportsStyle(style))
+      .shift();
+  }
+
+  private getSerializationParams(encodingObject: OpenAPIV3.EncodingObject) {
+    const [encodingObjectStyle]: OasStyleSerializerType[] = Object.values(
+      OasStyleSerializerType
+    ).filter((x) => x === encodingObject.style);
+
+    const style = encodingObjectStyle ?? OasStyleSerializerType.FORM;
+
+    return {
+      style,
+      explode: encodingObject.explode ?? false,
+      allowReserved: encodingObject.allowReserved ?? false,
+      contentType: encodingObject.contentType
+    };
+  }
+}

packages/oas/src/converter/parts/postdata/style-serializers/OasDeepObjectStyleSerializer.ts

@@ -0,0 +1,49 @@
+import {
+  OasStyleSerializer,
+  type OasStyleSerializerData,
+  type OasStyleSerializerOptions,
+  OasStyleSerializerType
+} from './OasStyleSerializer';
+import { isPrimitive } from '../../../../utils/isPrimitive';
+import { UriTemplator } from '../../UriTemplator';
+import { decodeReserved } from '../../../../utils/decodeReserved';
+
+export class OasDeepObjectStyleSerializer implements OasStyleSerializer {
+  public supportsStyle(style: OasStyleSerializerType): boolean {
+    return OasStyleSerializerType.DEEP_OBJECT === style;
+  }
+
+  public serialize(
+    { key, value }: OasStyleSerializerData,
+    { style, explode, allowReserved }: OasStyleSerializerOptions
+  ): string {
+    if (!this.supportsStyle(style) || !this.shouldSerialize(value, explode)) {
+      return '';
+    }
+
+    const result = Object.entries(value).reduce(
+      (acc, [prop, val]: [string, unknown]) => {
+        const keyValue = new UriTemplator()
+          .substitute(`?${key}[${prop}]={val}`, {
+            val: val ?? ''
+          })
+          .substring(1);
+
+        if (keyValue.length) {
+          const prefix = acc ? `${acc}&` : '';
+
+          return `${prefix}${keyValue}`;
+        }
+
+        return acc;
+      },
+      ''
+    );
+
+    return allowReserved ? decodeReserved(result) : result;
+  }
+
+  private shouldSerialize(value: unknown, explode: boolean): value is object {
+    return !!value && explode && !Array.isArray(value) && !isPrimitive(value);
+  }
+}

packages/oas/src/converter/parts/postdata/style-serializers/OasDefaultStylesSerializer.ts

@@ -0,0 +1,79 @@
+import {
+  OasStyleSerializer,
+  type OasStyleSerializerData,
+  type OasStyleSerializerOptions,
+  OasStyleSerializerType
+} from './OasStyleSerializer';
+import { isArrayOfPrimitives } from '../../../../utils/isArrayOfPrimitives';
+import { UriTemplator } from '../../UriTemplator';
+import { decodeReserved } from '../../../../utils/decodeReserved';
+
+export class OasDefaultStylesSerializer implements OasStyleSerializer {
+  private readonly CUSTOM_DELIMITERS: ReadonlyMap<
+    OasStyleSerializerType,
+    string
+  > = new Map<OasStyleSerializerType, string>([
+    [OasStyleSerializerType.PIPE_DELIMITED, '|'],
+    [OasStyleSerializerType.SPACE_DELIMITED, '%20']
+  ]);
+
+  public supportsStyle(style: OasStyleSerializerType): boolean {
+    return [
+      OasStyleSerializerType.PIPE_DELIMITED,
+      OasStyleSerializerType.SPACE_DELIMITED,
+      OasStyleSerializerType.FORM
+    ].includes(style);
+  }
+
+  public serialize(
+    { key, value }: OasStyleSerializerData,
+    { explode, allowReserved, style }: OasStyleSerializerOptions
+  ): string {
+    if (
+      !this.supportsStyle(style) ||
+      this.isNonArrayValueForArrayStyle(style, value)
+    ) {
+      return '';
+    }
+
+    const template = this.getTemplateString(key, explode, style);
+
+    let result = new UriTemplator()
+      .substitute(template, {
+        [key]: value
+      })
+      .substring(1);
+
+    result = this.replaceDelimiter(style, result);
+
+    return allowReserved ? decodeReserved(result) : result;
+  }
+
+  private isNonArrayValueForArrayStyle(
+    style: OasStyleSerializerType,
+    value: unknown
+  ) {
+    return (
+      [
+        OasStyleSerializerType.PIPE_DELIMITED,
+        OasStyleSerializerType.SPACE_DELIMITED
+      ].includes(style) && !isArrayOfPrimitives(value)
+    );
+  }
+
+  private replaceDelimiter(style: OasStyleSerializerType, result: string) {
+    const customDelimiter = this.CUSTOM_DELIMITERS.get(style);
+
+    return customDelimiter ? result.replace(/,/g, customDelimiter) : result;
+  }
+
+  private getTemplateString(
+    key: string,
+    explode: boolean,
+    style?: OasStyleSerializerType
+  ) {
+    const suffix = explode && style === OasStyleSerializerType.FORM ? '*' : '';
+
+    return `{?${key}${suffix}}`;
+  }
+}

packages/oas/src/converter/parts/postdata/style-serializers/OasStyleSerializer.ts

@@ -0,0 +1,26 @@
+export enum OasStyleSerializerType {
+  FORM = 'form',
+  SPACE_DELIMITED = 'spaceDelimited',
+  PIPE_DELIMITED = 'pipeDelimited',
+  DEEP_OBJECT = 'deepObject'
+}
+
+export interface OasStyleSerializerData {
+  key: string;
+  value: unknown;
+}
+
+export interface OasStyleSerializerOptions {
+  explode: boolean;
+  allowReserved: boolean;
+  style: OasStyleSerializerType;
+}
+
+export interface OasStyleSerializer {
+  supportsStyle(style: OasStyleSerializerType): boolean;
+
+  serialize(
+    serializerData: OasStyleSerializerData,
+    serializerOptions: OasStyleSerializerOptions
+  ): string;
+}

packages/oas/src/utils/decodeReserved.ts

@@ -0,0 +1,10 @@
+const specialChars = new Map(
+  Array.from(":/?#[]@!$&'()*+,;=").map((c) => [c.charCodeAt(0), c])
+);
+
+export const decodeReserved = (val: string) =>
+  val.replace(/%[0-9A-Fa-f]{2}/g, (match) => {
+    const decodedChar = specialChars.get(parseInt(match.substring(1), 16));
+
+    return decodedChar ? decodedChar : match;
+  });

packages/oas/src/utils/isArrayOfPrimitives.ts

@@ -0,0 +1,4 @@
+import { isPrimitive } from './isPrimitive';
+
+export const isArrayOfPrimitives = (value: unknown): boolean =>
+  Array.isArray(value) && value.every((item: unknown) => isPrimitive(item));

packages/oas/src/utils/isPrimitive.ts

@@ -0,0 +1,7 @@
+export const isPrimitive = (
+  value: unknown
+): value is null | undefined | string | boolean | number | bigint | symbol =>
+  // ADHOC: typeof null === 'object'
+  value === null ||
+  value === undefined ||
+  (typeof value !== 'object' && typeof value !== 'function');

packages/oas/tests/DefaultConverter.spec.ts

@@ -201,6 +201,11 @@ describe('DefaultConverter', () => {
         input: 'cookies.oas.yaml',
         expected: 'cookies.oas.result.json',
         message: 'should properly serialize cookies (oas)'
+      },
+      {
+        input: 'params-body-form-url-encoded.oas.yaml',
+        expected: 'params-body-form-url-encoded.oas.result.json',
+        message: 'should properly serialize form-url-encoded body (oas)'
       }
     ].forEach(({ input: inputFile, expected: expectedFile, message }) => {
       it(message, async () => {