@goast/typescript 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# typescript
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build typescript` to build the library.
+
+## Running unit tests
+
+Run `nx test typescript` to execute the unit tests via [Jest](https://jestjs.io).

package/assets/client/fetch/types.ts

@@ -0,0 +1,9 @@
+export type TypedResponse<T> = Response & {
+  json(): Promise<T>;
+};
+
+export type FetchClientOptions = {
+  readonly baseUrl?: string;
+  readonly fetch?: typeof fetch;
+  readonly headers?: Record<string, string>;
+};

package/assets/client/fetch/url-builder.ts

@@ -0,0 +1,36 @@
+export class UrlBuilder {
+  private path: string = '';
+  private pathParams: Record<string, string> = {};
+  private queryParams: Record<string, string> = {};
+
+  constructor(private readonly baseUrl?: string) {}
+
+  public withPath(path: string) {
+    this.path += path.startsWith('/') ? path : '/' + path;
+    return this;
+  }
+
+  public withPathParam(name: string, value: unknown) {
+    this.pathParams[name] = String(value);
+    return this;
+  }
+
+  public withQueryParam(name: string, value: unknown) {
+    if (value === undefined || value === null) {
+      if (name in this.queryParams) {
+        delete this.queryParams[name];
+      }
+    } else {
+      this.queryParams[name] = String(value);
+    }
+    return this;
+  }
+
+  public build() {
+    const queryString = Object.keys(this.queryParams)
+      .map((key) => `${key}=${this.queryParams[key]}`)
+      .join('&');
+    const path = this.path.replace(/\{([^}]+)\}/g, (_, name) => this.pathParams[name]);
+    return `${this.baseUrl}${path || '/'}${queryString ? '?' + queryString : ''}`;
+  }
+}

package/assets/service/angular/api-configuration.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+
+/**
+ * Global configuration
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class ApiConfiguration {
+  rootUrl: string = '@ROOT_URL@';
+}
+
+/**
+ * Parameters for `ApiModule.forRoot()`
+ */
+export interface ApiConfigurationParams {
+  rootUrl?: string;
+}

package/assets/service/angular/base-service.ts

@@ -0,0 +1,29 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+
+import { ApiConfiguration } from './api-configuration';
+
+/**
+ * Base class for services
+ */
+@Injectable()
+export class BaseService {
+  constructor(protected config: ApiConfiguration, protected http: HttpClient) {}
+
+  private _rootUrl: string = '';
+
+  /**
+   * Returns the root url for all operations in this service. If not set directly in this
+   * service, will fallback to `ApiConfiguration.rootUrl`.
+   */
+  get rootUrl(): string {
+    return this._rootUrl || this.config.rootUrl;
+  }
+
+  /**
+   * Sets the root URL for API operations in this service.
+   */
+  set rootUrl(rootUrl: string) {
+    this._rootUrl = rootUrl;
+  }
+}

package/assets/service/angular/request-builder.ts

@@ -0,0 +1,368 @@
+import { HttpRequest, HttpParameterCodec, HttpParams, HttpHeaders, HttpContext } from '@angular/common/http';
+
+/**
+ * Custom parameter codec to correctly handle the plus sign in parameter
+ * values. See https://github.com/angular/angular/issues/18261
+ */
+class ParameterCodec implements HttpParameterCodec {
+  encodeKey(key: string): string {
+    return encodeURIComponent(key);
+  }
+
+  encodeValue(value: string): string {
+    return encodeURIComponent(value);
+  }
+
+  decodeKey(key: string): string {
+    return decodeURIComponent(key);
+  }
+
+  decodeValue(value: string): string {
+    return decodeURIComponent(value);
+  }
+}
+const ParameterCodecInstance = new ParameterCodec();
+
+/**
+ * Defines the options for appending a parameter
+ */
+interface ParameterOptions {
+  style?: string;
+  explode?: boolean;
+}
+
+/**
+ * Base class for a parameter
+ */
+abstract class Parameter {
+  constructor(
+    public name: string,
+    public value: any,
+    public options: ParameterOptions,
+    defaultStyle: string,
+    defaultExplode: boolean
+  ) {
+    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;
+    }
+  }
+
+  serializeValue(value: any, separator = ','): string {
+    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') {
+      const array: string[] = [];
+      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
+ */
+class PathParameter extends Parameter {
+  constructor(name: string, value: any, options: ParameterOptions) {
+    super(name, value, options, 'simple', false);
+  }
+
+  append(path: string): string {
+    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;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  serializeValue(value: any, separator = ','): string {
+    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
+ */
+class QueryParameter extends Parameter {
+  constructor(name: string, value: any, options: ParameterOptions) {
+    super(name, value, options, 'form', true);
+  }
+
+  append(params: HttpParams): HttpParams {
+    if (this.value instanceof Array) {
+      // Array serialization
+      if (this.options.explode) {
+        for (const v of this.value) {
+          params = params.append(this.name, this.serializeValue(v));
+        }
+      } else {
+        const separator =
+          this.options.style === 'spaceDelimited' ? ' ' : this.options.style === 'pipeDelimited' ? '|' : ',';
+        return params.append(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.append(`${this.name}[${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.append(key, this.serializeValue(propVal));
+          }
+        }
+      } else {
+        // Append a single parameter whose values are a comma-separated list of key,value,key,value...
+        const array: any[] = [];
+        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.append(this.name, this.serializeValue(array));
+      }
+    } else if (this.value !== null && this.value !== undefined) {
+      // Plain value
+      params = params.append(this.name, this.serializeValue(this.value));
+    }
+    return params;
+  }
+}
+
+/**
+ * A parameter in the HTTP request header
+ */
+class HeaderParameter extends Parameter {
+  constructor(name: string, value: any, options: ParameterOptions) {
+    super(name, value, options, 'simple', false);
+  }
+
+  append(headers: HttpHeaders): HttpHeaders {
+    if (this.value !== null && this.value !== undefined) {
+      if (this.value instanceof Array) {
+        for (const v of this.value) {
+          headers = headers.append(this.name, this.serializeValue(v));
+        }
+      } else {
+        headers = headers.append(this.name, this.serializeValue(this.value));
+      }
+    }
+    return headers;
+  }
+}
+
+/**
+ * Helper to build http requests from parameters
+ */
+export class RequestBuilder {
+  private _path = new Map<string, PathParameter>();
+  private _query = new Map<string, QueryParameter>();
+  private _header = new Map<string, HeaderParameter>();
+  _bodyContent: any | null;
+  _bodyContentType?: string;
+
+  constructor(public rootUrl: string, public operationPath: string, public method: string) {}
+
+  /**
+   * Sets a path parameter
+   */
+  path(name: string, value: any, options?: ParameterOptions): void {
+    this._path.set(name, new PathParameter(name, value, options || {}));
+  }
+
+  /**
+   * Sets a query parameter
+   */
+  query(name: string, value: any, options?: ParameterOptions): void {
+    this._query.set(name, new QueryParameter(name, value, options || {}));
+  }
+
+  /**
+   * Sets a header parameter
+   */
+  header(name: string, value: any, options?: ParameterOptions): void {
+    this._header.set(name, new HeaderParameter(name, value, options || {}));
+  }
+
+  /**
+   * Sets the body content, along with the content type
+   */
+  body(value: any, contentType = 'application/json'): void {
+    if (value instanceof Blob) {
+      this._bodyContentType = value.type;
+    } else {
+      this._bodyContentType = contentType;
+    }
+    if (this._bodyContentType === 'application/x-www-form-urlencoded' && value !== null && typeof value === 'object') {
+      // Handle URL-encoded data
+      const pairs: Array<[string, string]> = [];
+      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 === 'multipart/form-data') {
+      // Handle multipart form data
+      const formData = new FormData();
+      if (value !== null && value !== undefined) {
+        for (const key of Object.keys(value)) {
+          const val = value[key];
+          if (val instanceof Array) {
+            for (const v of val) {
+              const toAppend = this.formDataValue(v);
+              if (toAppend !== null) {
+                formData.append(key, toAppend);
+              }
+            }
+          } else {
+            const toAppend = this.formDataValue(val);
+            if (toAppend !== null) {
+              formData.set(key, toAppend);
+            }
+          }
+        }
+      }
+      this._bodyContent = formData;
+    } else {
+      // The body is the plain content
+      this._bodyContent = value;
+    }
+  }
+
+  private formDataValue(value: any): any {
+    if (value === null || value === undefined) {
+      return null;
+    }
+    if (value instanceof Blob) {
+      return value;
+    }
+    if (typeof value === 'object') {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+
+  /**
+   * Builds the request with the current set parameters
+   */
+  build<T = any>(options?: {
+    /** Which content types to accept */
+    accept?: string;
+
+    /** The expected response type */
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+
+    /** Whether to report progress on uploads / downloads */
+    reportProgress?: boolean;
+
+    /** Allow passing HttpContext for HttpClient */
+    context?: HttpContext;
+  }): HttpRequest<T> {
+    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 = new HttpParams({
+      encoder: ParameterCodecInstance,
+    });
+    for (const queryParam of this._query.values()) {
+      httpParams = queryParam.append(httpParams);
+    }
+
+    // Header parameters
+    let httpHeaders = new HttpHeaders();
+    if (options.accept) {
+      httpHeaders = httpHeaders.append('Accept', options.accept);
+    }
+    for (const headerParam of this._header.values()) {
+      httpHeaders = headerParam.append(httpHeaders);
+    }
+
+    // Request content headers
+    if (this._bodyContentType && !(this._bodyContent instanceof FormData)) {
+      httpHeaders = httpHeaders.set('Content-Type', this._bodyContentType);
+    }
+
+    // Perform the request
+    return new HttpRequest<T>(this.method.toUpperCase(), url, this._bodyContent, {
+      params: httpParams,
+      headers: httpHeaders,
+      responseType: options.responseType,
+      reportProgress: options.reportProgress,
+      context: options.context,
+    });
+  }
+}

package/assets/service/angular/response-handlers.ts

@@ -0,0 +1,127 @@
+import { HttpErrorResponse } from '@angular/common/http';
+
+import { StrictHttpResponse } from './strict-http-response';
+
+type Response = { status: string; content: unknown };
+type PickRsp<T extends Response, K extends T['status']> = Exclude<T, Exclude<T, { status: K }>>;
+type ExcludeRsp<T extends Response, K extends T['status']> = Exclude<T, { status: K }>;
+type Handeled<T extends string | number | symbol> = { [K in T]: true };
+type SuccessCode = `2${number}`;
+type SuccessCodes<T extends Response> = Exclude<T['status'], Exclude<T['status'], SuccessCode>>;
+type ErrorCode = `${4 | 5}${number}` | 'other';
+type ErrorCodes<T extends Response> = Exclude<T['status'], Exclude<T['status'], ErrorCode>>;
+type RemoveVoid<T> = T extends void ? never : T;
+
+export class ResponseHandler<
+  I extends Response,
+  S extends I,
+  E extends Handeled<Exclude<I['status'], S['status']>>,
+  O
+> {
+  private readonly _dummy?: E;
+  private readonly _response: I;
+  private _isHandeled = false;
+  public result: O | PromiseLike<O> = undefined!;
+
+  constructor(response: I) {
+    this._response = response;
+  }
+
+  public handle<T extends Exclude<S['status'], 'other'>, U = undefined>(
+    status: T[] | T,
+    handler?: (r: PickRsp<S, T>, status: string) => U | PromiseLike<U>
+  ) {
+    const newThis = this.as<ExcludeRsp<S, T>, Handeled<T | keyof E>, RemoveVoid<U>>();
+    const matches = Array.isArray(status)
+      ? (status as string[]).indexOf(this._response.status.toString()) >= 0
+      : this._response.status.toString() === status;
+    if (matches && !this._isHandeled) {
+      this._isHandeled = true;
+      if (handler) {
+        newThis.result = handler(this._response as PickRsp<S, T>, this._response.status) as
+          | RemoveVoid<U>
+          | PromiseLike<RemoveVoid<U>>;
+      }
+    }
+    return newThis;
+  }
+
+  public handleSuccess<T = undefined>(handler?: (r: PickRsp<S, SuccessCode>, status: string) => T | PromiseLike<T>) {
+    const newThis = this.as<ExcludeRsp<S, SuccessCode>, Handeled<SuccessCodes<S> | keyof E>, RemoveVoid<T>>();
+    const matches = this._response.status.startsWith('2');
+    if (matches && !this._isHandeled) {
+      this._isHandeled = true;
+      if (handler) {
+        newThis.result = handler(this._response as PickRsp<S, SuccessCode>, this._response.status) as
+          | RemoveVoid<T>
+          | PromiseLike<RemoveVoid<T>>;
+      }
+    }
+    return newThis;
+  }
+
+  public handleError<T = undefined>(handler?: (r: PickRsp<S, ErrorCode>, status: string) => T | PromiseLike<T>) {
+    const newThis = this.as<ExcludeRsp<S, ErrorCode>, Handeled<ErrorCodes<S> | keyof E>, RemoveVoid<T>>();
+    const matches = this._response.status.startsWith('4') || this._response.status.startsWith('5');
+    if (matches && !this._isHandeled) {
+      this._isHandeled = true;
+      if (handler) {
+        newThis.result = handler(this._response as PickRsp<S, ErrorCode>, this._response.status) as
+          | RemoveVoid<T>
+          | PromiseLike<RemoveVoid<T>>;
+      }
+    }
+    return newThis;
+  }
+
+  public throwOnError() {
+    const newThis = this.as<ExcludeRsp<S, ErrorCode>, Handeled<ErrorCodes<S> | keyof E>, never>();
+    const matches = this._response.status.startsWith('4') || this._response.status.startsWith('5');
+    if (matches && !this._isHandeled) {
+      throw new UnhandeledResponseError(this._response);
+    }
+    return newThis;
+  }
+
+  private as<NewS extends I, NewE extends Handeled<Exclude<I['status'], NewS['status']>>, NewO>() {
+    return this as unknown as ResponseHandler<I, NewS, NewE, O | NewO>;
+  }
+}
+
+export class UnhandeledResponseError extends Error {
+  public readonly response: Response;
+
+  constructor(response: Response) {
+    super(`The response with status code '${response.status}' was not handeled.`, { cause: response });
+    this.response = response;
+  }
+}
+
+export type ResponseHandlerFn<T extends Response, O> = (
+  handler: ResponseHandler<T, T, object, never>
+) => ResponseHandler<T, never, { [K in T['status']]: true }, O>;
+
+export function handleResponse<R extends Response, O>(
+  response: Promise<StrictHttpResponse<unknown>>,
+  handler: ResponseHandlerFn<R, O>
+): Promise<O> {
+  return response
+    .then(
+      (r: StrictHttpResponse<unknown>) =>
+        <R>{
+          status: r.status.toString(),
+          content: r.body,
+        }
+    )
+    .catch((e: HttpErrorResponse) => {
+      if (!e.status) throw e;
+      return <R>{
+        status: e.status.toString(),
+        content: e.error,
+      };
+    })
+    .then((r: R) => {
+      const h = new ResponseHandler<R, R, object, never>(r);
+      return handler(h).result;
+    });
+}

package/assets/service/angular/strict-http-response.ts

@@ -0,0 +1,8 @@
+import { HttpResponse } from '@angular/common/http';
+
+/**
+ * Constrains the http response to not have the body defined as `T | null`, but `T` only.
+ */
+export type StrictHttpResponse<T> = HttpResponse<T> & {
+  readonly body: T;
+};

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/common-results"), exports);
+tslib_1.__exportStar(require("./lib/config"), exports);
+tslib_1.__exportStar(require("./lib/generators"), exports);
+tslib_1.__exportStar(require("./lib/file-builder"), exports);
+tslib_1.__exportStar(require("./lib/import-collection"), exports);
+tslib_1.__exportStar(require("./lib/utils"), exports);

package/cjs/lib/common-results.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/lib/config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTypeScriptGeneratorConfig = void 0;
+exports.defaultTypeScriptGeneratorConfig = {
+    charsTreatedAsEmptyLine: ['{'],
+    indent: { type: 'spaces', count: 2 },
+    importModuleTransformer: 'omit-extension',
+    typeNameCasing: 'pascal',
+    methodNameCasing: 'camel',
+    propertyNameCasing: 'camel',
+    enumValueNameCasing: 'pascal',
+    constantCasing: { casing: 'snake', wordCasing: 'all-upper' },
+    preferUnknown: true,
+    useSingleQuotes: true,
+};