Feature: TzKT object query string

package.json

@@ -1,5 +1,5 @@
 {
-    "name": "openapi-typescript-codegen",
+    "name": "@baking-bad/openapi-typescript-codegen",
     "version": "0.9.3",
     "description": "Library that generates Typescript clients based on the OpenAPI specification.",
     "author": "Ferdi Koomen",

src/openApi/v2/parser/getOperationPath.ts

@@ -12,5 +12,5 @@ export function getOperationPath(path: string): string {
         .replace(/\{(.*?)\}/g, (_, w: string) => {
             return `\${${getOperationParameterName(w)}}`;
         })
-        .replace('${apiVersion}', '${OpenAPI.VERSION}');
+        .replace('${apiVersion}', '${this.config.version}');
 }

src/openApi/v3/parser/getOperationPath.ts

@@ -12,5 +12,5 @@ export function getOperationPath(path: string): string {
         .replace(/\{(.*?)\}/g, (_, w: string) => {
             return `\${${getOperationParameterName(w)}}`;
         })
-        .replace('${apiVersion}', '${OpenAPI.VERSION}');
+        .replace('${apiVersion}', '${this.config.version}');
 }

src/templates/core/ApiOptions.hbs

@@ -0,0 +1,23 @@
+{{>header}}
+
+import type { Resolver, Headers } from './ApiRequestOptions';
+
+export type ApiOptions = {
+    baseUrl: string;
+    version: string;
+    withCredentials: boolean;
+    token?: string | Resolver<string>;
+    username?: string | Resolver<string>;
+    password?: string | Resolver<string>;
+    defaultHeaders?: Headers | Resolver<Headers>;
+}
+
+export const DefaultApiOptions: ApiOptions = {
+    baseUrl: '{{{server}}}',
+    version: '{{{version}}}',
+    withCredentials: false,
+    token: undefined,
+    username: undefined,
+    password: undefined,
+    defaultHeaders: undefined,
+};

src/templates/core/ApiRequestOptions.hbs

@@ -1,6 +1,16 @@
 {{>header}}
 
+export type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export type Headers = Record<string, string>;
+
 export type ApiRequestOptions = {
+    readonly baseUrl: string;
+    readonly withCredentials?: boolean;
+    readonly version: string;
+    readonly token?: string | Resolver<string>;
+    readonly username?: string | Resolver<string>;
+    readonly password?: string | Resolver<string>;
+    readonly defaultHeaders?: Headers | Resolver<Headers>;
     readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
     readonly path: string;
     readonly cookies?: Record<string, any>;

src/templates/core/fetch/getHeaders.hbs

@@ -1,8 +1,8 @@
 async function getHeaders(options: ApiRequestOptions): Promise<Headers> {
-    const token = await resolve(options, OpenAPI.TOKEN);
-    const username = await resolve(options, OpenAPI.USERNAME);
-    const password = await resolve(options, OpenAPI.PASSWORD);
-    const defaultHeaders = await resolve(options, OpenAPI.HEADERS);
+    const token = await resolve(options, options.token);
+    const username = await resolve(options, options.username);
+    const password = await resolve(options, options.password);
+    const defaultHeaders = await resolve(options, options.headers);
 
     const headers = new Headers({
         Accept: 'application/json',

src/templates/core/fetch/request.hbs

@@ -3,7 +3,6 @@
 import { ApiError } from './ApiError';
 import type { ApiRequestOptions } from './ApiRequestOptions';
 import type { ApiResult } from './ApiResult';
-import { OpenAPI } from './OpenAPI';
 
 {{>functions/isDefined}}
 

src/templates/core/fetch/sendRequest.hbs

@@ -4,7 +4,7 @@ async function sendRequest(options: ApiRequestOptions, url: string): Promise<Res
         headers: await getHeaders(options),
         body: getRequestBody(options),
     };
-    if (OpenAPI.WITH_CREDENTIALS) {
+    if (options.withCredentials) {
         request.credentials = 'include';
     }
     return await fetch(url, request);

src/templates/core/functions/getQueryString.hbs

@@ -7,6 +7,32 @@ function getQueryString(params: Record<string, any>): string {
                 value.forEach(value => {
                     qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
                 });
+            } else if (typeof value === 'object') {
+                switch (key) {
+                    case 'anyof': {
+                        qs.push(`${encodeURIComponent(key)}`);
+                        if (value.fields) {
+                            qs.push(`.${encodeURIComponent(Array(value.fileds).join('.'))}`);
+                        }
+                        qs.push(`=`);
+                        if (value.value) {
+                            qs.push(`${encodeURIComponent(value.value)}`);
+                        }
+                    }
+                    default: {
+                        Object.entries(value).map(raw => {
+                            let val = '';
+                            if (raw[1] instanceof Date) {
+                                val = (raw[1] as Date).toISOString();
+                            } else if (Array.isArray(raw[1])) {
+                                val = Array(raw[1]).join(',');
+                            } else {
+                                val = String(raw[1]);
+                            }
+                            qs.push(`${encodeURIComponent(key)}.${encodeURIComponent(String(raw[0]))}=${encodeURIComponent(val)}`);
+                        });
+                    }
+                }
             } else {
                 qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
             }

src/templates/core/functions/getUrl.hbs

@@ -1,6 +1,6 @@
 function getUrl(options: ApiRequestOptions): string {
     const path = options.path.replace(/[:]/g, '_');
-    const url = `${OpenAPI.BASE}${path}`;
+    const url = `${options.baseUrl}${path}`;
 
     if (options.query) {
         return `${url}${getQueryString(options.query)}`;

src/templates/core/node/getHeaders.hbs

@@ -1,8 +1,8 @@
 async function getHeaders(options: ApiRequestOptions): Promise<Headers> {
-    const token = await resolve(options, OpenAPI.TOKEN);
-    const username = await resolve(options, OpenAPI.USERNAME);
-    const password = await resolve(options, OpenAPI.PASSWORD);
-    const defaultHeaders = await resolve(options, OpenAPI.HEADERS);
+    const token = await resolve(options, options.token);
+    const username = await resolve(options, options.username);
+    const password = await resolve(options, options.password);
+    const defaultHeaders = await resolve(options, options.headers);
 
     const headers = new Headers({
         Accept: 'application/json',

src/templates/core/xhr/getHeaders.hbs

@@ -1,8 +1,8 @@
 async function getHeaders(options: ApiRequestOptions): Promise<Headers> {
-    const token = await resolve(options, OpenAPI.TOKEN);
-    const username = await resolve(options, OpenAPI.USERNAME);
-    const password = await resolve(options, OpenAPI.PASSWORD);
-    const defaultHeaders = await resolve(options, OpenAPI.HEADERS);
+    const token = await resolve(options, options.token);
+    const username = await resolve(options, options.username);
+    const password = await resolve(options, options.password);
+    const defaultHeaders = await resolve(options, options.headers);
 
     const headers = new Headers({
         Accept: 'application/json',

src/templates/exportService.hbs

@@ -5,13 +5,22 @@
 import type { {{{this}}} } from '../models/{{{this}}}';
 {{/each}}
 {{/if}}
+import { ApiRequestOptions } from '../core/ApiRequestOptions';
 import { request as __request } from '../core/request';
-{{#if @root.useVersion}}
-import { OpenAPI } from '../core/OpenAPI';
-{{/if}}
+import { ApiOptions } from '../core/ApiOptions';
 
 export class {{{name}}} {
 
+    private readonly config: ApiOptions;
+
+    /**
+     * creates a new service
+     * @param config the configuration to use
+     */
+    public constructor(config: ApiOptions) {
+        this.config = config;
+    }
+
     {{#each operations}}
     /**
     {{#if deprecated}}
@@ -35,8 +44,44 @@ export class {{{name}}} {
     {{/each}}
      * @throws ApiError
      */
-    public static async {{{name}}}({{>parameters}}): Promise<{{>result}}> {
-        const result = await __request({
+    public async {{{name}}}({{>parameters}}): Promise<{{>result}}> {
+        const options = this.{{{name}}}ApiRequestOptions(
+            {{~#if parameters.length~}}
+            {
+            {{#each parameters}}
+                {{{name}}}: {{{name}}},
+            {{/each}}
+            }
+            {{/if}}
+        );
+        const result = await __request(options);
+        return result.body;
+    }
+
+    /**
+    {{#if deprecated}}
+     * @deprecated
+    {{/if}}
+     * **used to get the request options without making a http request**
+    {{#if summary}}
+     * {{{summary}}}
+    {{/if}}
+    {{#if description}}
+     * {{{description}}}
+    {{/if}}
+    {{#unless @root.useOptions}}
+    {{#if parameters}}
+    {{#each parameters}}
+     * @param {{{name}}} {{{description}}}
+    {{/each}}
+    {{/if}}
+    {{/unless}}
+     * @returns ApiRequestOptions the request options to fulfill a http request
+     * @throws ApiError
+     */
+    public {{{name}}}ApiRequestOptions({{>parameters}}): ApiRequestOptions {
+        return {
+            ...this.config,
             method: '{{{method}}}',
             path: `{{{path}}}`,
             {{#if parametersCookie}}
@@ -83,9 +128,8 @@ export class {{{name}}} {
                 {{/each}}
             },
             {{/if}}
-        });
-        return result.body;
+        };
     }
 
     {{/each}}
-}
+}

src/templates/index.hbs

@@ -2,7 +2,7 @@
 {{#if @root.exportCore}}
 
 export { ApiError } from './core/ApiError';
-export { OpenAPI } from './core/OpenAPI';
+export { ApiOptions, DefaultApiOptions } from './core/ApiOptions';
 {{/if}}
 {{#if @root.exportModels}}
 {{#if models}}

src/utils/registerHandlebarTemplates.ts

@@ -27,7 +27,7 @@ import nodeGetResponseBody from '../templates/core/node/getResponseBody.hbs';
 import nodeGetResponseHeader from '../templates/core/node/getResponseHeader.hbs';
 import nodeRequest from '../templates/core/node/request.hbs';
 import nodeSendRequest from '../templates/core/node/sendRequest.hbs';
-import templateCoreSettings from '../templates/core/OpenAPI.hbs';
+import templateCoreSettings from '../templates/core/ApiOptions.hbs';
 import templateCoreRequest from '../templates/core/request.hbs';
 import xhrGetHeaders from '../templates/core/xhr/getHeaders.hbs';
 import xhrGetRequestBody from '../templates/core/xhr/getRequestBody.hbs';

src/utils/writeClientCore.ts

@@ -20,7 +20,7 @@ export async function writeClientCore(client: Client, templates: Templates, outp
         version: client.version,
     };
 
-    await writeFile(resolve(outputPath, 'OpenAPI.ts'), templates.core.settings(context));
+    await writeFile(resolve(outputPath, 'ApiOptions.ts'), templates.core.settings(context));
     await writeFile(resolve(outputPath, 'ApiError.ts'), templates.core.apiError({}));
     await writeFile(resolve(outputPath, 'ApiRequestOptions.ts'), templates.core.apiRequestOptions({}));
     await writeFile(resolve(outputPath, 'ApiResult.ts'), templates.core.apiResult({}));

src/utils/writeClientServices.ts

@@ -6,7 +6,7 @@ import { writeFile } from './fileSystem';
 import { format } from './format';
 import { Templates } from './registerHandlebarTemplates';
 
-const VERSION_TEMPLATE_STRING = 'OpenAPI.VERSION';
+const VERSION_TEMPLATE_STRING = 'this.config.version';
 
 /**
  * Generate Services using the Handlebar template and write to disk.

test/custom/request.ts

@@ -3,11 +3,10 @@
 /* eslint-disable */
 import type { ApiRequestOptions } from './ApiRequestOptions';
 import type { ApiResult } from './ApiResult';
-import { OpenAPI } from './OpenAPI';
 
 export async function request(options: ApiRequestOptions): Promise<ApiResult> {
 
-    const url = `${OpenAPI.BASE}${options.path}`;
+    const url = `${options.baseUrl}${options.path}`;
 
     // Do your request...