@grandlinex/swagger-mate 0.30.8

package/res/templates/class/BaseCon.ts

@@ -0,0 +1,377 @@
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED
+ * DO NOT EDIT THIS FILE
+ */
+
+import FormData from 'form-data';
+
+export type ErrorType = {
+  type: string;
+  global?: string[];
+  field?: { key: string; message: string }[];
+};
+
+export type HeaderType = string | string[] | number | undefined;
+export type HandleRes<T> = {
+  success: boolean;
+  data: T | null;
+  code?: number;
+  error?: ErrorType;
+  headers?: Record<string, HeaderType>;
+};
+
+export type PathParam = { [key: string]: string | number | undefined };
+export function isErrorType(x: any): x is ErrorType {
+  return x && typeof x === 'object' && x.type === 'error';
+}
+
+export interface ConHandleConfig {
+  headers?: Record<string, string>;
+  param?: PathParam;
+  query?: PathParam;
+}
+export interface ConHandleResponse<T> {
+  code: number;
+  data: T | null;
+  headers: Record<string, HeaderType>;
+}
+
+export interface ConHandle {
+  get<T>(url: string, config?: ConHandleConfig): Promise<ConHandleResponse<T>>;
+  post<T, J>(
+    url: string,
+    body?: J,
+    config?: ConHandleConfig
+  ): Promise<ConHandleResponse<T>>;
+  patch<T, J>(
+    url: string,
+    body?: J,
+    config?: ConHandleConfig
+  ): Promise<ConHandleResponse<T>>;
+
+  delete<T>(
+    url: string,
+    config?: ConHandleConfig
+  ): Promise<ConHandleResponse<T>>;
+}
+export default class BaseCon {
+  api: string;
+
+  permanentHeader: undefined | Record<string, string>;
+
+  authorization: string | null;
+
+  disconnected: boolean;
+
+  failFlag: boolean;
+
+  logger: (arg: any) => void;
+
+  con: ConHandle;
+
+  reconnect: () => Promise<boolean>;
+
+  onReconnect: (con: BaseCon) => Promise<boolean>;
+
+  constructor(conf: {
+    con: ConHandle;
+    endpoint: string;
+    logger?: (arg: any) => void;
+  }) {
+    this.api = conf.endpoint;
+    this.logger = conf.logger || console.log;
+    this.disconnected = true;
+    this.authorization = null;
+    this.failFlag = false;
+    this.con = conf.con;
+    this.reconnect = async () => {
+      this.disconnected = true;
+      return false;
+    };
+    this.onReconnect = () => Promise.resolve(true);
+    this.handle = this.handle.bind(this);
+  }
+
+  // Class helper functions
+
+  isConnected() {
+    return this.authorization !== null && !this.disconnected;
+  }
+
+  token() {
+    return this.authorization || '';
+  }
+
+  p(path: string, config?: ConHandleConfig) {
+    let pp = path;
+    if (config?.param) {
+      const e = Object.keys(config.param);
+      for (const d of e) {
+        pp = pp.replace(`{${d}}`, `${config.param[d]}`);
+      }
+    }
+    if (config?.query) {
+      const e = Object.keys(config.query);
+      const slices = [];
+      for (const d of e) {
+        if (config.query[d]) {
+          slices.push(`${d}=${config.query[d]}`);
+        }
+      }
+      if (slices.length > 0) {
+        pp += `?${slices.join('&')}`;
+      }
+    }
+    return `${this.api}${pp}`;
+  }
+
+  async ping(): Promise<boolean> {
+    try {
+      const version = await this.con.get<{ api: number }>(this.p('/version'));
+      return version.data?.api === 1 && version.code === 200;
+    } catch (e) {
+      this.logger('ping failed');
+      return false;
+    }
+  }
+
+  async test(email: string, password: string): Promise<boolean> {
+    const ping = await this.ping();
+
+    if (ping) {
+      try {
+        this.logger({ email, password });
+        const con = await this.con.post<
+          { token: string },
+          {
+            username: string;
+            token: string;
+          }
+        >(this.p('/token'), {
+          username: email,
+          token: password,
+        });
+        return con.code === 200 || con.code === 201;
+      } catch (e) {
+        this.logger(e);
+        this.logger('cant connect to backend');
+      }
+    }
+    this.logger('test ping failed');
+
+    return false;
+  }
+
+  async testToken(): Promise<boolean> {
+    const ping = await this.ping();
+
+    if (ping) {
+      try {
+        const con = await this.con.get<{ token: string }>(
+          this.p('/test/auth'),
+          {
+            headers: {
+              Authorization: this.token(),
+            },
+          }
+        );
+        return con.code === 200 || con.code === 201;
+      } catch (e) {
+        this.logger(e);
+        this.logger('cant connect to backend');
+      }
+    }
+    this.logger('test ping failed');
+
+    return false;
+  }
+
+  async connect(email: string, pw: string): Promise<boolean> {
+    const ping = await this.ping();
+
+    if (ping) {
+      try {
+        const token = await this.con.post<
+          { token: string },
+          {
+            username: string;
+            token: string;
+          }
+        >(this.p('/token'), {
+          username: email,
+          token: pw,
+        });
+        // TODO check token
+        if (token.code === 200 || token.code === 201) {
+          this.authorization = `Bearer ${token.data?.token}`;
+          this.disconnected = false;
+          this.reconnect = async () => {
+            return (await this.connect(email, pw)) && (await this.testToken());
+          };
+          return true;
+        }
+      } catch (e) {
+        this.logger(e);
+      }
+    }
+    this.logger('cant connect to backend');
+    this.authorization = null;
+    this.disconnected = true;
+    return false;
+  }
+
+  /**
+   * Enable client before auth
+   */
+  fakeEnableClient() {
+    this.authorization = 'DEBUG';
+    this.disconnected = false;
+  }
+
+  async handle<T, J>(
+    type: 'POST' | 'GET' | 'PATCH' | 'DELETE',
+    path: string,
+    body?: J,
+    config?: ConHandleConfig
+  ): Promise<HandleRes<T>> {
+    if (!this.authorization || this.disconnected) {
+      this.logger('Disconnected');
+      return {
+        success: false,
+        data: null,
+        code: -1,
+      };
+    }
+    let formHeader = null;
+    const cK = body as any;
+    if (
+      cK &&
+      (cK instanceof FormData || typeof cK?.getHeaders === 'function')
+    ) {
+      formHeader = cK?.getHeaders?.() || {};
+    } else {
+      formHeader = {};
+    }
+
+    let dat: ConHandleResponse<T> | null;
+    switch (type) {
+      case 'GET':
+        dat = await this.con.get<T>(this.p(path, config), {
+          ...config,
+          headers: {
+            Authorization: this.token(),
+            ...formHeader,
+            ...config?.headers,
+            ...this.permanentHeader,
+          },
+        });
+        break;
+      case 'POST':
+        dat = await this.con.post<T, J>(this.p(path, config), body, {
+          ...config,
+          headers: {
+            Authorization: this.token(),
+            ...formHeader,
+            ...config?.headers,
+            ...this.permanentHeader,
+          },
+        });
+        break;
+      case 'PATCH':
+        dat = await this.con.patch<T, J>(this.p(path, config), body, {
+          ...config,
+          headers: {
+            Authorization: this.token(),
+            ...formHeader,
+            ...config?.headers,
+            ...this.permanentHeader,
+          },
+        });
+        break;
+      case 'DELETE':
+        dat = await this.con.delete<T>(this.p(path, config), {
+          ...config,
+          headers: {
+            Authorization: this.token(),
+            ...formHeader,
+            ...config?.headers,
+            ...this.permanentHeader,
+          },
+        });
+        break;
+      default:
+        return {
+          success: false,
+          data: null,
+          code: -1,
+        };
+    }
+
+    let error: ErrorType | undefined;
+    if (isErrorType(dat.data)) {
+      error = dat.data;
+    }
+    let x = false;
+    switch (dat.code) {
+      case 200:
+      case 201:
+        return {
+          success: true,
+          data: dat.data,
+          code: dat.code,
+          error,
+          headers: dat.headers,
+        };
+
+      case 498:
+        x = await this.reconnect();
+        if (x) {
+          this.onReconnect(this).catch((dx) => {
+            this.logger(dx);
+          });
+          return this.handle(type, path, body, config);
+        }
+        this.reconnect = async () => {
+          this.disconnected = true;
+          return false;
+        };
+
+        this.disconnected = true;
+        return {
+          success: false,
+          data: null,
+          code: dat.code,
+          error,
+          headers: dat.headers,
+        };
+
+      case 401:
+        this.logger('AUTH NOT VALID');
+        this.disconnected = true;
+        return {
+          success: false,
+          data: null,
+          code: dat.code,
+          error,
+          headers: dat.headers,
+        };
+      case 403:
+        return {
+          success: false,
+          data: null,
+          error,
+          code: dat.code,
+          headers: dat.headers,
+        };
+
+      default:
+        return {
+          success: false,
+          data: null,
+          error,
+          code: dat.code,
+          headers: dat.headers,
+        };
+    }
+  }
+}

package/res/templates/class/CApiCon.ts

@@ -0,0 +1,11 @@
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED
+ * DO NOT EDIT THIS FILE
+ */
+import * as TX from './ApiTypes';
+import { HandleRes } from './BaseCon';
+import IApiCon from './IApiCon';
+
+export default abstract class CApiCon implements IApiCon{
+  /* REPLACE_ME */
+}

package/res/templates/class/FetchCon.ts

@@ -0,0 +1,93 @@
+import { ConHandle, ConHandleResponse } from './BaseCon.js';
+
+async function fcTransform<T>(
+  r: Promise<Response>
+): Promise<ConHandleResponse<T>> {
+  const res = await r;
+  const head: Record<string, any> = {};
+
+  res.headers.forEach((val: any, key: any) => {
+    head[key] = val;
+  });
+
+  let data = null;
+
+  if (head['content-type']?.includes('application/json')) {
+    data = await res.json();
+  } else if (head['content-type']?.includes('form-data')) {
+    data = await res.formData();
+  } else if (head['content-type']?.includes('octet-stream')) {
+    data = await res.arrayBuffer();
+  } else if (head['content-type']?.includes('text/plain')) {
+    data = await res.text();
+  }
+
+  return {
+    code: res.status,
+    data,
+    headers: head,
+  };
+}
+
+function bodyTransform(r: any, headers?: Record<string, string>) {
+  if (!r) {
+    return {
+      headers,
+    };
+  }
+  if (r instanceof FormData) {
+    return {
+      body: r,
+      headers: {
+        ...headers,
+      },
+    };
+  }
+  return {
+    body: JSON.stringify(r),
+    headers: {
+      ...headers,
+      'content-type': 'application/json',
+    },
+  };
+}
+
+const FetchCon: ConHandle = {
+  get: async (url, config) => {
+    return fcTransform(
+      fetch(url, {
+        method: 'GET',
+        headers: {
+          accept: 'application/json, text/plain, */*',
+          ...config?.headers,
+        },
+      })
+    );
+  },
+  post: async (url, body, config) => {
+    return fcTransform(
+      fetch(url, {
+        method: 'POST',
+        ...bodyTransform(body, config?.headers),
+      })
+    );
+  },
+  patch: async (url, body, config) => {
+    return fcTransform(
+      fetch(url, {
+        method: 'PATCH',
+        ...bodyTransform(body, config?.headers),
+      })
+    );
+  },
+  delete: async (url, config) => {
+    return fcTransform(
+      fetch(url, {
+        method: 'DELETE',
+        headers: config?.headers,
+      })
+    );
+  },
+};
+
+export default FetchCon;

package/res/templates/class/IApiCon.ts

@@ -0,0 +1,10 @@
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED
+ * DO NOT EDIT THIS FILE
+ */
+import * as TX from './ApiTypes';
+import { HandleRes } from './BaseCon';
+
+export default interface IApiCon {
+  /* REPLACE_ME */
+}

package/res/templates/class/NodeCon.ts

@@ -0,0 +1,164 @@
+import FormData from 'form-data';
+import * as http from 'http';
+import * as https from 'https';
+import { IncomingMessage } from 'http';
+import { RequestOptions } from 'https';
+
+import {
+  ConHandle,
+  ConHandleConfig,
+  ConHandleResponse,
+  HeaderType,
+} from './BaseCon.js';
+
+function selectClient(url: string) {
+  if (url.startsWith('https')) {
+    return https;
+  }
+  return http;
+}
+
+async function fcTransform<T>(
+  message: IncomingMessage,
+  raw: any
+): Promise<ConHandleResponse<T>> {
+  let data = null;
+
+  if (message.headers['content-type']?.includes('application/json')) {
+    data = JSON.parse(raw);
+  } else if (message.headers['content-type']?.includes('form-data')) {
+    data = null; // await res.formData()
+  } else if (message.headers['content-type']?.includes('octet-stream')) {
+    data = Buffer.from(raw);
+  } else if (message.headers['content-type']?.startsWith('text/')) {
+    data = Buffer.from(raw).toString('utf8');
+  }
+
+  return {
+    code: message.statusCode || -1,
+    data,
+    headers: message.headers,
+  };
+}
+function bodyTransform(
+  r: any,
+  headers?: Record<string, HeaderType>
+): {
+  headers: Record<string, HeaderType>;
+  body: any;
+} {
+  if (!r) {
+    return {
+      headers: headers || {},
+      body: undefined,
+    };
+  }
+  if (r instanceof FormData) {
+    return {
+      body: r,
+      headers: {
+        ...headers,
+        'content-type': 'multipart/form-data',
+      },
+    };
+  }
+  return {
+    body: JSON.stringify(r),
+    headers: {
+      ...headers,
+      'content-type': 'application/json',
+    },
+  };
+}
+async function makeRequest<T, J>(
+  url: string,
+  option: RequestOptions,
+  body?: J,
+  config?: ConHandleConfig
+): Promise<ConHandleResponse<T>> {
+  return new Promise((resolve) => {
+    let headers: Record<string, any> = config?.headers || {};
+    let transForm = null;
+    if (body) {
+      transForm = bodyTransform(body, option.headers);
+      headers = {
+        ...headers,
+        ...transForm.headers,
+      };
+    }
+
+    const req = selectClient(url)
+      .request(
+        url,
+        {
+          headers,
+          ...option,
+        },
+        (res) => {
+          let data = '';
+
+          // A chunk of data has been received.
+          res.on('data', (chunk) => {
+            data += chunk;
+          });
+
+          // The whole response has been received. Print out the result.
+          res.on('end', () => {
+            resolve(fcTransform(res, data));
+          });
+        }
+      )
+      .on('error', (err) => {
+        console.log(`Error: ${err.message}`);
+
+        resolve({
+          code: -1,
+          data: null,
+          headers: {},
+        });
+      });
+
+    if (transForm && transForm.body) {
+      req.write(transForm.body);
+    }
+    req.end();
+  });
+}
+
+const NodeCon: ConHandle = {
+  get: async (url, config) => {
+    return makeRequest(url, {}, undefined, config);
+  },
+  post: async (url, body, config) => {
+    return makeRequest(
+      url,
+      {
+        method: 'POST',
+      },
+      body,
+      config
+    );
+  },
+  patch: async (url, body, config) => {
+    return makeRequest(
+      url,
+      {
+        method: 'PATCH',
+      },
+      body,
+      config
+    );
+  },
+  delete: async (url, config) => {
+    return makeRequest(
+      url,
+      {
+        method: 'DELETE',
+      },
+      undefined,
+      config
+    );
+  },
+};
+
+export default NodeCon;

package/res/templates/class/index.ts

@@ -0,0 +1,18 @@
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED
+ * DO NOT EDIT THIS FILE
+ */
+import FormData from 'form-data';
+import ApiCon from './ApiCon';
+import BaseCon from './BaseCon';
+import CApiCon from './CApiCon';
+import IApiCon from './IApiCon';
+
+import NodeCon from './NodeCon';
+import FetchCon from './FetchCon';
+import AxiosCon from './AxiosCon';
+
+export * from './BaseCon';
+export * from './ApiTypes';
+export { ApiCon, BaseCon, CApiCon, IApiCon, FormData , NodeCon, FetchCon, AxiosCon };
+export default ApiCon;