@goast/typescript 0.3.1 → 0.3.3

package/README.md

@@ -35,6 +35,8 @@ main();
   - Depends on the output of the `TypeScriptModelsGenerator` generator.
 - [`TypeScriptEasyNetworkStubsGenerator`](https://github.com/MaSch0212/goast/wiki/TypeScript%20Easy%20Network%20Stubs%20Generator): Generates [easy-network-stub](https://github.com/LoaderB0T/easy-network-stub) classes from paths in the OpenAPI specification(s).
   - Depends on the output of the `TypeScriptModelsGenerator` generator.
+- [`TypeScriptK6ClientsGenerator`](https://github.com/MaSch0212/goast/wiki/TypeScript%20K6%20Clients%20Generator): Generates [k6](https://k6.io/) clients from paths in the OpenAPI specification(s).
+  - Depends on the output of the `TypeScriptModelsGenerator` generator.
 
 ## API Documentation 📖
 

package/assets/client/k6/request-builder.js

@@ -0,0 +1,411 @@
+// @ts-check
+
+import http from 'k6/http';
+
+/**
+ * Defines the options for appending a parameter
+ * @typedef {object} ParameterOptions
+ * @property {string} [style]
+ * @property {boolean} [explode]
+ */
+
+/**
+ * Base class for a parameter
+ * @abstract
+ * @property {string} name
+ * @property {*} value
+ * @property {ParameterOptions} options
+ */
+class Parameter {
+  /**
+   * @param {string} name
+   * @param {*} value
+   * @param {ParameterOptions} options
+   * @param {string} defaultStyle
+   * @param {boolean} defaultExplode
+   */
+  constructor(name, value, options, defaultStyle, defaultExplode) {
+    this.name = name;
+    this.value = value;
+    this.options = options || {};
+    if (this.options.style === null || this.options.style === undefined) {
+      this.options.style = defaultStyle;
+    }
+    if (this.options.explode === null || this.options.explode === undefined) {
+      this.options.explode = defaultExplode;
+    }
+  }
+
+  /**
+   * @param {*} value
+   * @param {string} separator
+   * @returns {string}
+   */
+  serializeValue(value, separator = ',') {
+    if (value === null || value === undefined) {
+      return '';
+    } else if (value instanceof Array) {
+      return value
+        .map((v) => this.serializeValue(v).split(separator).join(encodeURIComponent(separator)))
+        .join(separator);
+    } else if (typeof value === 'object') {
+      /** @type {string[]} */
+      const array = [];
+      for (const key of Object.keys(value)) {
+        let propVal = value[key];
+        if (propVal !== null && propVal !== undefined) {
+          propVal = this.serializeValue(propVal).split(separator).join(encodeURIComponent(separator));
+          if (this.options.explode) {
+            array.push(`${key}=${propVal}`);
+          } else {
+            array.push(key);
+            array.push(propVal);
+          }
+        }
+      }
+      return array.join(separator);
+    } else {
+      return String(value);
+    }
+  }
+}
+
+/**
+ * A parameter in the operation path
+ * @param {string} name
+ * @param {*} value
+ * @param {ParameterOptions} options
+ */
+class PathParameter extends Parameter {
+  /**
+   * @param {string} name
+   * @param {*} value
+   * @param {ParameterOptions} options
+   */
+  constructor(name, value, options) {
+    super(name, value, options, 'simple', false);
+  }
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  append(path) {
+    let value = this.value;
+    if (value === null || value === undefined) {
+      value = '';
+    }
+    let prefix = this.options.style === 'label' ? '.' : '';
+    const separator = this.options.explode ? (prefix === '' ? ',' : prefix) : ',';
+    let alreadySerialized = false;
+    if (this.options.style === 'matrix') {
+      // The parameter name is just used as prefix, except in some cases...
+      prefix = `;${this.name}=`;
+      if (this.options.explode && typeof value === 'object') {
+        prefix = ';';
+        if (value instanceof Array) {
+          // For arrays we have to repeat the name for each element
+          value = value.map((v) => `${this.name}=${this.serializeValue(v, ';')}`);
+          value = value.join(';');
+          alreadySerialized = true;
+        } else {
+          // For objects we have to put each the key / value pairs
+          value = this.serializeValue(value, ';');
+          alreadySerialized = true;
+        }
+      }
+    }
+    value = prefix + (alreadySerialized ? value : this.serializeValue(value, separator));
+    // Replace both the plain variable and the corresponding variant taking in the prefix and explode into account
+    path = path.replace(`{${this.name}}`, value);
+    path = path.replace(`{${prefix}${this.name}${this.options.explode ? '*' : ''}}`, value);
+    return path;
+  }
+
+  /**
+   * @param {*} value
+   * @param {string} separator
+   * @returns {string}
+   */
+  serializeValue(value, separator = ',') {
+    let result = typeof value === 'string' ? encodeURIComponent(value) : super.serializeValue(value, separator);
+    result = result.replace(/%3D/g, '=');
+    result = result.replace(/%3B/g, ';');
+    result = result.replace(/%2C/g, ',');
+    return result;
+  }
+}
+
+/**
+ * A parameter in the query
+ * @param {string} name
+ * @param {*} value
+ * @param {ParameterOptions} options
+ */
+class QueryParameter extends Parameter {
+  /**
+   * @param {string} name
+   * @param {*} value
+   * @param {ParameterOptions} options
+   */
+  constructor(name, value, options) {
+    super(name, value, options, 'form', true);
+  }
+
+  /**
+   * @param {string} params
+   * @returns {string}
+   */
+  append(params) {
+    if (this.value instanceof Array) {
+      // Array serialization
+      if (this.options.explode) {
+        for (const v of this.value) {
+          params = `${params}${params ? '&' : '?'}${encodeURIComponent(this.name)}=${this.serializeValue(v)}`;
+        }
+      } else {
+        const separator =
+          this.options.style === 'spaceDelimited' ? ' ' : this.options.style === 'pipeDelimited' ? '|' : ',';
+        return `${params}${params ? '&' : '?'}${encodeURIComponent(this.name)}=${this.serializeValue(this.value, separator)}`;
+      }
+    } else if (this.value !== null && typeof this.value === 'object') {
+      // Object serialization
+      if (this.options.style === 'deepObject') {
+        // Append a parameter for each key, in the form `name[key]`
+        for (const key of Object.keys(this.value)) {
+          const propVal = this.value[key];
+          if (propVal !== null && propVal !== undefined) {
+            params = `${params}${params ? '&' : '?'}${encodeURIComponent(this.name)}[${encodeURIComponent(
+              key,
+            )}]=${this.serializeValue(propVal)}`;
+          }
+        }
+      } else if (this.options.explode) {
+        // Append a parameter for each key without using the parameter name
+        for (const key of Object.keys(this.value)) {
+          const propVal = this.value[key];
+          if (propVal !== null && propVal !== undefined) {
+            params = `${params}${params ? '&' : '?'}${encodeURIComponent(key)}=${this.serializeValue(propVal)}`;
+          }
+        }
+      } else {
+        // Append a single parameter whose values are a comma-separated list of key,value,key,value...
+        const array = [];
+        for (const key of Object.keys(this.value)) {
+          const propVal = this.value[key];
+          if (propVal !== null && propVal !== undefined) {
+            array.push(key);
+            array.push(propVal);
+          }
+        }
+        params = `${params}${params ? '&' : '?'}${encodeURIComponent(this.name)}=${this.serializeValue(array)}`;
+      }
+    } else if (this.value !== null && this.value !== undefined) {
+      // Plain value
+      params = `${params}${params ? '&' : '?'}${encodeURIComponent(this.name)}=${this.serializeValue(this.value)}`;
+    }
+    return params;
+  }
+}
+
+/**
+ * A parameter in the HTTP request header
+ */
+class HeaderParameter extends Parameter {
+  /**
+   * @param {string} name
+   * @param {*} value
+   * @param {ParameterOptions} options
+   */
+  constructor(name, value, options) {
+    super(name, value, options, 'simple', false);
+  }
+
+  /**
+   * @param {Object.<string, string>} headers
+   * @returns {Object.<string, string>}
+   */
+  append(headers) {
+    if (this.value !== null && this.value !== undefined) {
+      if (this.value instanceof Array) {
+        throw new Error('Array header values are not supported');
+      } else {
+        headers[this.name] = this.serializeValue(this.value);
+      }
+    }
+    return headers;
+  }
+}
+
+/**
+ * Helper to build http requests from parameters
+ * @property {string} rootUrl
+ * @property {string} operationPath
+ * @property {string} method
+ */
+export class RequestBuilder {
+  /**
+   * @param {string} rootUrl
+   * @param {string} operationPath
+   * @param {string} method
+   */
+  constructor(rootUrl, operationPath, method) {
+    this.rootUrl = rootUrl;
+    this.operationPath = operationPath;
+    this.method = method;
+    this._path = new Map();
+    this._query = new Map();
+    this._header = new Map();
+    this._bodyContent = null;
+    this._bodyContentType = undefined;
+  }
+
+  /**
+   * Sets a path parameter
+   * @param {string} name
+   * @param {*} value
+   * @param {ParameterOptions} [options]
+   */
+  path(name, value, options) {
+    this._path.set(name, new PathParameter(name, value, options || {}));
+  }
+
+  /**
+   * Sets a query parameter
+   * @param {string} name
+   * @param {*} value
+   * @param {ParameterOptions} [options]
+   */
+  query(name, value, options) {
+    this._query.set(name, new QueryParameter(name, value, options || {}));
+  }
+
+  /**
+   * Sets a header parameter
+   * @param {string} name
+   * @param {*} value
+   * @param {ParameterOptions} [options]
+   */
+  header(name, value, options) {
+    this._header.set(name, new HeaderParameter(name, value, options || {}));
+  }
+
+  /**
+   * Sets the body content, along with the content type
+   * @param {*} value
+   * @param {string} [contentType]
+   */
+  body(value, contentType = 'application/json') {
+    this._bodyContentType = contentType;
+    if (this._bodyContentType === 'application/x-www-form-urlencoded' && value !== null && typeof value === 'object') {
+      // Handle URL-encoded data
+      /** @type {[string, string][]} */
+      const pairs = [];
+      for (const key of Object.keys(value)) {
+        let val = value[key];
+        if (!(val instanceof Array)) {
+          val = [val];
+        }
+        for (const v of val) {
+          const formValue = this.formDataValue(v);
+          if (formValue !== null) {
+            pairs.push([key, formValue]);
+          }
+        }
+      }
+      this._bodyContent = pairs.map((p) => `${encodeURIComponent(p[0])}=${encodeURIComponent(p[1])}`).join('&');
+    } else if (this._bodyContentType.indexOf('json') !== -1 && value !== null && typeof value === 'object') {
+      this._bodyContent = JSON.stringify(value);
+    } else {
+      // The body is the plain content
+      this._bodyContent = value;
+    }
+  }
+
+  /**
+   * @private
+   * @param {*} value
+   * @returns {*}
+   */
+  formDataValue(value) {
+    if (value === null || value === undefined) {
+      return null;
+    }
+    if (typeof value === 'object') {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+
+  /**
+   * @typedef {object} BuildOptions
+   * @property {string} [accept]
+   * @property {import('k6/http').Params} [params]
+   */
+
+  /**
+   * Builds the request with the current set parameters
+   * @param {BuildOptions} [options]
+   * @returns {import('k6/http').Response}
+   */
+  build(options) {
+    // Perform the request
+    return http.request(...this.buildRequestParams(options));
+  }
+
+  /**
+   * Builds the request with the current set parameters
+   * @param {BuildOptions} [options]
+   * @returns {Promise<import('k6/http').Response>}
+   */
+  buildAsync(options) {
+    // Perform the request
+    return http.asyncRequest(...this.buildRequestParams(options));
+  }
+
+  /**
+   * @private
+   * @param {BuildOptions} [options]
+   * @returns {Parameters<typeof import('k6/http').request>}
+   */
+  buildRequestParams(options) {
+    options = options || {};
+
+    // Path parameters
+    let path = this.operationPath;
+    for (const pathParam of this._path.values()) {
+      path = pathParam.append(path);
+    }
+    const url = this.rootUrl + path;
+
+    // Query parameters
+    let httpParams = '';
+    for (const queryParam of this._query.values()) {
+      httpParams = queryParam.append(httpParams);
+    }
+
+    // Header parameters
+    /** @type {Object.<string, string>} */
+    let httpHeaders = {};
+    if (options.accept) {
+      httpHeaders['Accept'] = options.accept;
+    }
+    for (const headerParam of this._header.values()) {
+      httpHeaders = headerParam.append(httpHeaders);
+    }
+
+    // Request content headers
+    if (this._bodyContentType) {
+      httpHeaders['Content-Type'] = this._bodyContentType;
+    }
+
+    return [
+      this.method.toUpperCase(),
+      url + httpParams,
+      this._bodyContent,
+      Object.assign({}, options.params, {
+        headers: Object.assign({}, httpHeaders, options.params ? options.params.headers : {}),
+      }),
+    ];
+  }
+}

package/cjs/lib/ast/nodes/method.js

@@ -11,7 +11,7 @@ const node_1 = require("../node");
 const write_ts_nodes_1 = require("../utils/write-ts-nodes");
 class TsMethod extends node_1.TsNode {
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
         super(options);
         this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
         this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(core_1.notNullish)) !== null && _c !== void 0 ? _c : [];
@@ -19,12 +19,13 @@ class TsMethod extends node_1.TsNode {
         this.static = (_e = options.static) !== null && _e !== void 0 ? _e : false;
         this.abstract = (_f = options.abstract) !== null && _f !== void 0 ? _f : false;
         this.override = (_g = options.override) !== null && _g !== void 0 ? _g : false;
+        this.async = (_h = options.async) !== null && _h !== void 0 ? _h : false;
         this.name = options.name;
-        this.optional = (_h = options.optional) !== null && _h !== void 0 ? _h : false;
-        this.generics = (_k = (_j = options.generics) === null || _j === void 0 ? void 0 : _j.filter(core_1.notNullish)) !== null && _k !== void 0 ? _k : [];
-        this.parameters = (_m = (_l = options.parameters) === null || _l === void 0 ? void 0 : _l.filter(core_1.notNullish)) !== null && _m !== void 0 ? _m : [];
-        this.returnType = (_o = options.returnType) !== null && _o !== void 0 ? _o : null;
-        this.body = (_p = options.body) !== null && _p !== void 0 ? _p : null;
+        this.optional = (_j = options.optional) !== null && _j !== void 0 ? _j : false;
+        this.generics = (_l = (_k = options.generics) === null || _k === void 0 ? void 0 : _k.filter(core_1.notNullish)) !== null && _l !== void 0 ? _l : [];
+        this.parameters = (_o = (_m = options.parameters) === null || _m === void 0 ? void 0 : _m.filter(core_1.notNullish)) !== null && _o !== void 0 ? _o : [];
+        this.returnType = (_p = options.returnType) !== null && _p !== void 0 ? _p : null;
+        this.body = (_q = options.body) !== null && _q !== void 0 ? _q : null;
     }
     onWrite(builder) {
         const isInObjectDeclaration = this.getParentNode(builder) instanceof object_1.TsObject;
@@ -43,6 +44,8 @@ class TsMethod extends node_1.TsNode {
             builder.append('abstract ');
         if (this.override)
             builder.append('override ');
+        if (this.async)
+            builder.append('async ');
         builder.append(this.inject.afterModifiers);
         builder.append(this.inject.beforeName, this.name, this.inject.afterName);
         if (this.optional)

package/cjs/lib/ast/nodes/reference.js

@@ -8,11 +8,12 @@ const write_ts_generic_parameters_1 = require("../utils/write-ts-generic-paramet
 const write_ts_nodes_1 = require("../utils/write-ts-nodes");
 class TsReference extends node_1.TsNode {
     constructor(options) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         super(options);
         this.name = options.name;
         this.moduleNameOrfilePath = (_a = options.moduleNameOrfilePath) !== null && _a !== void 0 ? _a : null;
         this.generics = (_c = (_b = options.generics) === null || _b === void 0 ? void 0 : _b.filter(core_1.notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.importType = (_d = options.importType) !== null && _d !== void 0 ? _d : 'import';
     }
     onWrite(builder) {
         builder.append(this.name);
@@ -33,12 +34,16 @@ exports.TsReference = TsReference;
 TsReference.addImportHandlers = [
     {
         builderClass: file_builder_1.TypeScriptFileBuilder,
-        handler: (builder, reference) => builder.addImport(reference.name, reference.moduleNameOrfilePath),
+        handler: (builder, reference) => {
+            if (reference.moduleNameOrfilePath) {
+                builder.addImport(reference.name, reference.moduleNameOrfilePath, { type: reference.importType });
+            }
+        },
     },
 ];
 const createReference = (name, moduleNameOrfilePath, options) => new TsReference({ ...options, name, moduleNameOrfilePath });
 function _createFactory(name, moduleNameOrfilePath) {
-    return Object.assign(() => createReference(name, moduleNameOrfilePath), {
+    return Object.assign((options) => createReference(name, moduleNameOrfilePath, options), {
         refName: name,
         moduleNameOrfilePath,
     });
@@ -47,7 +52,7 @@ function createFactory(name, moduleNameOrfilePath) {
     return _createFactory(name, moduleNameOrfilePath);
 }
 function _createGenericFactory(name, moduleNameOrfilePath) {
-    return Object.assign((generics) => createReference(name, moduleNameOrfilePath, { generics }), {
+    return Object.assign((generics, options) => createReference(name, moduleNameOrfilePath, { ...options, generics }), {
         refName: name,
         moduleNameOrfilePath,
         infer: () => createReference(name, moduleNameOrfilePath),

package/cjs/lib/ast/references/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rxjs = exports.angular = exports.easyNetworkStub = void 0;
+exports.k6 = exports.rxjs = exports.angular = exports.easyNetworkStub = void 0;
 const tslib_1 = require("tslib");
 exports.easyNetworkStub = tslib_1.__importStar(require("./easy-network-stub"));
 exports.angular = tslib_1.__importStar(require("./angular"));
 exports.rxjs = tslib_1.__importStar(require("./rxjs"));
+exports.k6 = tslib_1.__importStar(require("./k6"));
 tslib_1.__exportStar(require("./typescript"), exports);

package/cjs/lib/ast/references/k6.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.params = exports.response = exports.jsonValue = void 0;
+const reference_1 = require("../nodes/reference");
+// k6
+exports.jsonValue = reference_1.tsReference.factory('JSONValue', 'k6');
+// h6/http
+exports.response = reference_1.tsReference.factory('Response', 'k6/http');
+exports.params = reference_1.tsReference.factory('Params', 'k6/http');

package/cjs/lib/file-builder.js

@@ -24,8 +24,8 @@ class TypeScriptFileBuilder extends core_1.SourceBuilder {
             useSingleQuotes: this.options.useSingleQuotes,
         });
     }
-    addImport(name, moduleNameOrfilePath) {
-        this.imports.addImport(name, moduleNameOrfilePath);
+    addImport(name, moduleNameOrfilePath, options) {
+        this.imports.addImport(name, moduleNameOrfilePath, options);
         return this;
     }
     addExport(name, filePath) {
@@ -37,7 +37,12 @@ class TypeScriptFileBuilder extends core_1.SourceBuilder {
         this.imports.clear();
     }
     toString(addPadding = true) {
+        var _a;
         const builder = new core_1.SourceBuilder(this.options);
+        if ((_a = this.filePath) === null || _a === void 0 ? void 0 : _a.match(/\.[cm]?js$/)) {
+            builder.appendLine('// @ts-check');
+        }
+        builder.ensurePreviousLineEmpty();
         this.imports.writeTo(builder);
         const baseString = super.toString();
         if (baseString && addPadding) {
@@ -55,10 +60,10 @@ class TypeScriptFileBuilder extends core_1.SourceBuilder {
             value.write(this);
         }
     }
-    appendModelUsage(type) {
+    appendModelUsage(type, options) {
         this.append(type.component);
         for (const i of type.imports) {
-            this.addImport(i.name, i.modulePath);
+            this.addImport(i.name, i.modulePath, options);
         }
         return this;
     }

package/cjs/lib/generators/index.js

@@ -4,5 +4,6 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./file-generator"), exports);
 tslib_1.__exportStar(require("./models"), exports);
 tslib_1.__exportStar(require("./services/angular-services"), exports);
-tslib_1.__exportStar(require("./services/fetch-clients"), exports);
 tslib_1.__exportStar(require("./services/easy-network-stub"), exports);
+tslib_1.__exportStar(require("./services/fetch-clients"), exports);
+tslib_1.__exportStar(require("./services/k6-clients"), exports);

package/cjs/lib/generators/models/model-generator.js

@@ -21,7 +21,7 @@ class DefaultTypeScriptModelGenerator extends file_generator_1.TypeScriptFileGen
             return {
                 component: name,
                 filePath,
-                imports: [{ kind: 'file', name, modulePath: filePath }],
+                imports: [{ kind: 'file', name, modulePath: filePath, type: 'import' }],
                 additionalExports: fileContent.values
                     .filter((x) => typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x)
                     .filter((x) => x.name !== name)

package/cjs/lib/generators/services/k6-clients/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./k6-client-generator"), exports);
+tslib_1.__exportStar(require("./k6-clients-generator"), exports);
+tslib_1.__exportStar(require("./models"), exports);