@ventlio/tanstack-query 0.1.0

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const API_BASE_URL = "";

package/dist/constants/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const API_BASE_URL = '';
+
+exports.API_BASE_URL = API_BASE_URL;
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './request';
+export * from './useMyHook';

package/dist/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var index = require('./constants/index.js');
+var axiosInstance = require('./request/axios-instance.js');
+var buildFormData = require('./request/buildFormData.js');
+var makeRequest = require('./request/make-request.js');
+var request_enum = require('./request/request.enum.js');
+var transformer = require('./request/transformer.js');
+var useMyHook = require('./useMyHook.js');
+
+
+
+exports.API_BASE_URL = index.API_BASE_URL;
+exports.axiosInstance = axiosInstance.axiosInstance;
+exports.buildFormData = buildFormData.buildFormData;
+exports.makeRequest = makeRequest.makeRequest;
+Object.defineProperty(exports, 'ContentType', {
+	enumerable: true,
+	get: function () { return request_enum.ContentType; }
+});
+Object.defineProperty(exports, 'HttpMethod', {
+	enumerable: true,
+	get: function () { return request_enum.HttpMethod; }
+});
+exports.errorTransformer = transformer.errorTransformer;
+exports.successTransformer = transformer.successTransformer;
+exports.useMyHook = useMyHook.useMyHook;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -0,0 +1,110 @@
+import axios from 'axios';
+import { useState } from 'react';
+
+const API_BASE_URL = '';
+
+const axiosInstance = (headers) => {
+    return axios.create({
+        baseURL: 'https://api.ventlio.com',
+        timeout: 100000,
+        headers,
+    });
+};
+
+const buildFormData = (body) => {
+    const formData = new FormData();
+    const bodyKeys = Object.keys(body);
+    bodyKeys.forEach((key) => {
+        formData.append(key, body[key]);
+    });
+    body = formData;
+    return { body };
+};
+
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+})(HttpMethod || (HttpMethod = {}));
+var ContentType;
+(function (ContentType) {
+    ContentType["APPLICATION_JSON"] = "application/json";
+    ContentType["MULTIPART_FORM_DATA"] = "multipart/form-data";
+})(ContentType || (ContentType = {}));
+
+//
+const errorTransformer = (data) => {
+    return {
+        message: data.message,
+        statusCode: data.statusCode,
+        timeStamp: new Date(),
+        status: false,
+        data: data.data,
+    };
+};
+//
+const successTransformer = (data) => {
+    return {
+        message: data.message ?? 'Request successful',
+        statusCode: data.statusCode,
+        timeStamp: new Date(),
+        status: true,
+        data: data.data,
+    };
+};
+
+async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, formData, }) {
+    // construct api full url
+    const apiFullUrl = `${API_BASE_URL}${path}`;
+    // configure body
+    body = formData ? buildFormData(body) : body;
+    // configure request header
+    const headers = {
+        Authorization: `Bearer ${bearerToken}`,
+    };
+    if (!formData) {
+        headers['Content-Type'] = ContentType.APPLICATION_JSON;
+    }
+    try {
+        const axios = axiosInstance(headers);
+        //   send request
+        const resp = await axios({
+            url: apiFullUrl,
+            method,
+            data: formData ? body : JSON.stringify(body),
+        });
+        // get response json
+        const jsonResp = await resp.data();
+        // get response code
+        const responseCode = resp.status;
+        if (responseCode > 299) {
+            // server returned an error
+            return errorTransformer({ ...jsonResp, statusCode: responseCode });
+        }
+        return successTransformer({
+            ...jsonResp,
+            statusCode: responseCode,
+        });
+    }
+    catch (error) {
+        return errorTransformer({
+            statusCode: error.status,
+            message: error.message,
+            code: error.status || error.statusCode,
+        });
+    }
+}
+
+const useMyHook = () => {
+    const [value, setValue] = useState('');
+    const updateValue = (newValue) => {
+        setValue(newValue);
+    };
+    return [value, updateValue];
+};
+
+export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, successTransformer, useMyHook };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/request/axios-instance.d.ts

@@ -0,0 +1,2 @@
+import type { AxiosInstance, RawAxiosRequestHeaders } from 'axios';
+export declare const axiosInstance: (headers: RawAxiosRequestHeaders) => AxiosInstance;

package/dist/request/axios-instance.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var axios = require('axios');
+
+const axiosInstance = (headers) => {
+    return axios.create({
+        baseURL: 'https://api.ventlio.com',
+        timeout: 100000,
+        headers,
+    });
+};
+
+exports.axiosInstance = axiosInstance;
+//# sourceMappingURL=axios-instance.js.map

package/dist/request/axios-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"axios-instance.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/dist/request/buildFormData.d.ts

@@ -0,0 +1,3 @@
+export declare const buildFormData: (body: any) => {
+    body: any;
+};

package/dist/request/buildFormData.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const buildFormData = (body) => {
+    const formData = new FormData();
+    const bodyKeys = Object.keys(body);
+    bodyKeys.forEach((key) => {
+        formData.append(key, body[key]);
+    });
+    body = formData;
+    return { body };
+};
+
+exports.buildFormData = buildFormData;
+//# sourceMappingURL=buildFormData.js.map

package/dist/request/buildFormData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildFormData.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/dist/request/index.d.ts

@@ -0,0 +1,6 @@
+export * from './axios-instance';
+export * from './buildFormData';
+export * from './make-request';
+export * from './request.enum';
+export * from './request.interface';
+export * from './transformer';

package/dist/request/make-request.d.ts

@@ -0,0 +1,2 @@
+import type { IMakeRequest } from './request.interface';
+export declare function makeRequest<TResponse>({ body, method, path, bearerToken, formData, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;

package/dist/request/make-request.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var index = require('../constants/index.js');
+var axiosInstance = require('./axios-instance.js');
+var buildFormData = require('./buildFormData.js');
+var request_enum = require('./request.enum.js');
+var transformer = require('./transformer.js');
+
+async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, bearerToken, formData, }) {
+    // construct api full url
+    const apiFullUrl = `${index.API_BASE_URL}${path}`;
+    // configure body
+    body = formData ? buildFormData.buildFormData(body) : body;
+    // configure request header
+    const headers = {
+        Authorization: `Bearer ${bearerToken}`,
+    };
+    if (!formData) {
+        headers['Content-Type'] = request_enum.ContentType.APPLICATION_JSON;
+    }
+    try {
+        const axios = axiosInstance.axiosInstance(headers);
+        //   send request
+        const resp = await axios({
+            url: apiFullUrl,
+            method,
+            data: formData ? body : JSON.stringify(body),
+        });
+        // get response json
+        const jsonResp = await resp.data();
+        // get response code
+        const responseCode = resp.status;
+        if (responseCode > 299) {
+            // server returned an error
+            return transformer.errorTransformer({ ...jsonResp, statusCode: responseCode });
+        }
+        return transformer.successTransformer({
+            ...jsonResp,
+            statusCode: responseCode,
+        });
+    }
+    catch (error) {
+        return transformer.errorTransformer({
+            statusCode: error.status,
+            message: error.message,
+            code: error.status || error.statusCode,
+        });
+    }
+}
+
+exports.makeRequest = makeRequest;
+//# sourceMappingURL=make-request.js.map

package/dist/request/make-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-request.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/request/request.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+export declare enum ContentType {
+    APPLICATION_JSON = "application/json",
+    MULTIPART_FORM_DATA = "multipart/form-data"
+}

package/dist/request/request.enum.js

@@ -0,0 +1,16 @@
+'use strict';
+
+exports.HttpMethod = void 0;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+})(exports.HttpMethod || (exports.HttpMethod = {}));
+exports.ContentType = void 0;
+(function (ContentType) {
+    ContentType["APPLICATION_JSON"] = "application/json";
+    ContentType["MULTIPART_FORM_DATA"] = "multipart/form-data";
+})(exports.ContentType || (exports.ContentType = {}));
+//# sourceMappingURL=request.enum.js.map

package/dist/request/request.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.enum.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/dist/request/request.interface.d.ts

@@ -0,0 +1,39 @@
+import type { HttpMethod } from './request.enum';
+export interface IMakeRequest {
+    path: string;
+    body?: BodyInit | null;
+    method?: HttpMethod;
+    bearerToken?: string;
+    formData?: boolean;
+}
+export interface AxiosInstanceOption {
+    bearerToken?: string;
+    contentType?: string;
+}
+export interface IRequestError {
+    statusCode: number;
+    message: string;
+    timeStamp: Date;
+    status: boolean;
+    data?: any;
+}
+export interface IRequestSuccess<T> {
+    statusCode: number;
+    message: string;
+    timeStamp: Date;
+    status: boolean;
+    data: T;
+}
+export interface IServerRequestSuccess {
+    status?: boolean;
+    data: any;
+    message?: string;
+}
+export interface IServerRequestError {
+    status?: boolean;
+    code?: number;
+    success?: boolean;
+    message: string;
+    error?: Record<string, any>;
+    data?: Record<string, any>;
+}

package/dist/request/transformer.d.ts

@@ -0,0 +1,7 @@
+import type { IRequestError, IRequestSuccess, IServerRequestError, IServerRequestSuccess } from './request.interface';
+export declare const errorTransformer: (data: IServerRequestError & {
+    statusCode: number;
+}) => IRequestError;
+export declare const successTransformer: <T>(data: IServerRequestSuccess & {
+    statusCode: number;
+}) => IRequestSuccess<T>;

package/dist/request/transformer.js

@@ -0,0 +1,26 @@
+'use strict';
+
+//
+const errorTransformer = (data) => {
+    return {
+        message: data.message,
+        statusCode: data.statusCode,
+        timeStamp: new Date(),
+        status: false,
+        data: data.data,
+    };
+};
+//
+const successTransformer = (data) => {
+    return {
+        message: data.message ?? 'Request successful',
+        statusCode: data.statusCode,
+        timeStamp: new Date(),
+        status: true,
+        data: data.data,
+    };
+};
+
+exports.errorTransformer = errorTransformer;
+exports.successTransformer = successTransformer;
+//# sourceMappingURL=transformer.js.map

package/dist/request/transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/useMyHook.d.ts

@@ -0,0 +1 @@
+export declare const useMyHook: () => [string, (newValue: string) => void];

package/dist/useMyHook.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var react = require('react');
+
+const useMyHook = () => {
+    const [value, setValue] = react.useState('');
+    const updateValue = (newValue) => {
+        setValue(newValue);
+    };
+    return [value, updateValue];
+};
+
+exports.useMyHook = useMyHook;
+//# sourceMappingURL=useMyHook.js.map

package/dist/useMyHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMyHook.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@ventlio/tanstack-query",
+  "version": "0.1.0",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": {
+    "email": "ventliodevs@gmail.com",
+    "name": "Ventlio",
+    "url": "https://ventlio.com"
+  },
+  "scripts": {
+    "build": "rollup --config rollup.config.ts --configPlugin rollup-plugin-typescript2",
+    "build:watch": "yarn build -w"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^4.26.1",
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+    "axios": "^1.3.4",
+    "react-native": "*"
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    }
+  },
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.mjs",
+    "default": "./dist/index.js"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^24.0.1",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@tanstack/react-query": "^4.26.1",
+    "@types/axios": "^0.14.0",
+    "@types/node": "*",
+    "@types/react": "^18.0.28",
+    "@typescript-eslint/eslint-plugin": "^5.54.1",
+    "@typescript-eslint/parser": "^5.54.1",
+    "axios": "^1.3.4",
+    "eslint": "^8.36.0",
+    "eslint-config-google": "^0.14.0",
+    "eslint-config-prettier": "^8.7.0",
+    "eslint-import-resolver-typescript": "^3.5.3",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "prettier": "^2.8.4",
+    "react": "^18.2.0",
+    "rollup": "^3.19.1",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.5.0",
+    "typescript": "^4.9.5"
+  },
+  "files": [
+    "dist/app/*",
+    "dist/**/*",
+    "src"
+  ],
+  "dependencies": {
+    "rmf": "^2.0.0"
+  }
+}

package/src/constants/index.ts

@@ -0,0 +1 @@
+export const API_BASE_URL = '';

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './request';
+export * from './useMyHook';

package/src/request/axios-instance.ts

@@ -0,0 +1,12 @@
+import type { AxiosInstance, RawAxiosRequestHeaders } from 'axios';
+import axios from 'axios';
+
+export const axiosInstance = (
+  headers: RawAxiosRequestHeaders
+): AxiosInstance => {
+  return axios.create({
+    baseURL: 'https://api.ventlio.com',
+    timeout: 100000,
+    headers,
+  });
+};

package/src/request/buildFormData.ts

@@ -0,0 +1,11 @@
+export const buildFormData = (body: any) => {
+  const formData = new FormData();
+
+  const bodyKeys = Object.keys(body);
+  bodyKeys.forEach((key) => {
+    formData.append(key, body[key]);
+  });
+  body = formData;
+
+  return { body };
+};

package/src/request/index.ts

@@ -0,0 +1,6 @@
+export * from './axios-instance';
+export * from './buildFormData';
+export * from './make-request';
+export * from './request.enum';
+export * from './request.interface';
+export * from './transformer';

package/src/request/make-request.ts

@@ -0,0 +1,63 @@
+import { API_BASE_URL } from '../constants';
+import { axiosInstance } from './axios-instance';
+
+import { buildFormData } from './buildFormData';
+import { ContentType, HttpMethod } from './request.enum';
+import type { IMakeRequest } from './request.interface';
+import { errorTransformer, successTransformer } from './transformer';
+
+export async function makeRequest<TResponse>({
+  body,
+  method = HttpMethod.GET,
+  path,
+  bearerToken,
+  formData,
+}: IMakeRequest) {
+  // construct api full url
+  const apiFullUrl = `${API_BASE_URL}${path}`;
+
+  // configure body
+  body = formData ? (buildFormData(body) as any) : body;
+
+  // configure request header
+  const headers: Record<string, any> = {
+    Authorization: `Bearer ${bearerToken}`,
+  };
+
+  if (!formData) {
+    headers['Content-Type'] = ContentType.APPLICATION_JSON;
+  }
+
+  try {
+    const axios = axiosInstance(headers);
+
+    //   send request
+    const resp = await axios({
+      url: apiFullUrl,
+      method,
+      data: formData ? body : JSON.stringify(body),
+    });
+
+    // get response json
+    const jsonResp: any = await resp.data();
+
+    // get response code
+    const responseCode = resp.status;
+
+    if (responseCode > 299) {
+      // server returned an error
+      return errorTransformer({ ...jsonResp, statusCode: responseCode });
+    }
+
+    return successTransformer<TResponse>({
+      ...jsonResp,
+      statusCode: responseCode,
+    });
+  } catch (error: any) {
+    return errorTransformer({
+      statusCode: error.status,
+      message: error.message,
+      code: error.status || error.statusCode,
+    });
+  }
+}

package/src/request/request.enum.ts

@@ -0,0 +1,12 @@
+export enum HttpMethod {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+  DELETE = 'DELETE',
+}
+
+export enum ContentType {
+  APPLICATION_JSON = 'application/json',
+  MULTIPART_FORM_DATA = 'multipart/form-data',
+}

package/src/request/request.interface.ts

@@ -0,0 +1,45 @@
+import type { HttpMethod } from './request.enum';
+
+export interface IMakeRequest {
+  path: string;
+  body?: BodyInit | null;
+  method?: HttpMethod;
+  bearerToken?: string;
+  formData?: boolean;
+}
+
+export interface AxiosInstanceOption {
+  bearerToken?: string;
+  contentType?: string;
+}
+
+export interface IRequestError {
+  statusCode: number;
+  message: string;
+  timeStamp: Date;
+  status: boolean;
+  data?: any;
+}
+
+export interface IRequestSuccess<T> {
+  statusCode: number;
+  message: string;
+  timeStamp: Date;
+  status: boolean;
+  data: T;
+}
+
+export interface IServerRequestSuccess {
+  status?: boolean;
+  data: any;
+  message?: string;
+}
+
+export interface IServerRequestError {
+  status?: boolean;
+  code?: number;
+  success?: boolean;
+  message: string;
+  error?: Record<string, any>;
+  data?: Record<string, any>;
+}

package/src/request/transformer.ts

@@ -0,0 +1,32 @@
+import type {
+  IRequestError,
+  IRequestSuccess,
+  IServerRequestError,
+  IServerRequestSuccess,
+} from './request.interface';
+
+//
+export const errorTransformer = (
+  data: IServerRequestError & { statusCode: number }
+): IRequestError => {
+  return {
+    message: data.message,
+    statusCode: data.statusCode,
+    timeStamp: new Date(),
+    status: false,
+    data: data.data,
+  };
+};
+
+//
+export const successTransformer = <T>(
+  data: IServerRequestSuccess & { statusCode: number }
+): IRequestSuccess<T> => {
+  return {
+    message: data.message ?? 'Request successful',
+    statusCode: data.statusCode,
+    timeStamp: new Date(),
+    status: true,
+    data: data.data,
+  };
+};

package/src/useMyHook.ts

@@ -0,0 +1,11 @@
+import { useState } from 'react';
+
+export const useMyHook = (): [string, (newValue: string) => void] => {
+  const [value, setValue] = useState('');
+
+  const updateValue = (newValue: string) => {
+    setValue(newValue);
+  };
+
+  return [value, updateValue];
+};