@ps-aux/api-client-axios 0.0.4 → 0.0.6-rc-2

package/dist/api-client-axios/src/AxiosOpenApiHttpClient.d.ts

@@ -0,0 +1,7 @@
+import { AxiosInstance } from 'axios';
+import { HttpClient } from './t';
+import { PlatformHelper } from './platform/types';
+import { UrlConverter } from '@ps-aux/api-client-common/src';
+export declare const noOpUrlConverter: () => UrlConverter;
+export declare const springBootUrlConverter: () => UrlConverter;
+export declare const createHttpClient: (axios: AxiosInstance, platform: PlatformHelper, urlConverter?: UrlConverter) => HttpClient;

package/dist/api-client-axios/src/browser.d.ts

@@ -0,0 +1,4 @@
+import { AxiosInstance } from 'axios';
+import { HttpClient } from './t';
+export declare const createHttpClient: (axios: AxiosInstance, urlConverter?: import("@ps-aux/api-client-common/src").UrlConverter) => HttpClient;
+export * from './commonExports';

package/dist/api-client-axios/src/commonExports.d.ts

@@ -0,0 +1,3 @@
+export { UrlConverter } from '@ps-aux/api-client-common';
+export { HttpClient, Request, RequestParams } from './t';
+export { springBootUrlConverter, noOpUrlConverter } from './AxiosOpenApiHttpClient';

package/dist/api-client-axios/src/node.d.ts

@@ -0,0 +1,4 @@
+import { AxiosInstance } from 'axios';
+import { HttpClient } from './t';
+export declare const createHttpClient: (axios: AxiosInstance, urlConverter?: import("@ps-aux/api-client-common/src").UrlConverter) => HttpClient;
+export * from './commonExports';

package/dist/{platform → api-client-axios/src/platform}/browser.d.ts

@@ -1,4 +1,4 @@
-import { PlatformHelper } from "./types";
+import { PlatformHelper } from './types';
 export declare class BrowserPlatFormHelper implements PlatformHelper {
     isFile: (obj: any) => boolean;
     getFileAndName: (obj: any) => {
@@ -6,5 +6,5 @@ export declare class BrowserPlatFormHelper implements PlatformHelper {
         name: string;
     };
     isFileList: (obj: any) => boolean;
-    newFormData: () => any;
+    newFormData: () => FormData;
 }

package/dist/api-client-axios/src/platform/foo.d.ts

@@ -0,0 +1 @@
+export { BrowserPlatFormHelper as Platform } from './browser';

package/dist/{mytyp.d.ts → api-client-axios/src/t.d.ts}

@@ -1,7 +1,5 @@
 export type ContentType = {};
-export type RequestParams = {
-    fileDownload?: boolean;
-};
+export type RequestParams = {};
 export declare const ContentType: {
     Json: string;
     FormData: string;
@@ -14,7 +12,6 @@ export type Request = {
     body?: any;
     type?: string;
     secure?: boolean;
-    fileDownload?: boolean;
 };
 export type HttpClient<Any = any> = {
     request: <Data, A = any>(req: Request) => Promise<Data>;

package/dist/api-client-common/src/index.d.ts

@@ -0,0 +1,9 @@
+export { serializeQueryForSpringBoot } from './serializeQueryForSpringBoot';
+export { serializeQueryWithQs } from './serializeQueryWithQs';
+export type UrlConverter = (req: {
+    path: string;
+    query?: Record<string, unknown>;
+}) => {
+    url: string;
+    params?: any;
+};

package/dist/api-client-common/src/serializeQueryForSpringBoot.d.ts

@@ -0,0 +1,5 @@
+/**
+ *  Brings the 1st level to the 0th level.
+ *  Flats the object by nesting with '.' path separator.
+ */
+export declare const serializeQueryForSpringBoot: (obj: object) => string;

package/dist/api-client-common/src/serializeQueryWithQs.d.ts

@@ -0,0 +1 @@
+export declare const serializeQueryWithQs: (obj: object) => string;

package/dist/browser.esm.js

@@ -0,0 +1,340 @@
+import 'qs';
+
+const ContentType = {
+    Json: 'application/json',
+    FormData: 'multipart/form-data',
+};
+
+const convertToFormData = (payload, platform) => {
+    const formData = platform.newFormData();
+    const addProp = (key, val) => {
+        if (Array.isArray(val) || platform.isFileList(val)) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore - seems that FileList is iterable despite the warning
+            // TODO change to other iteration method if this is not true
+            for (const valItem of val) {
+                addProp(key, valItem);
+            }
+        }
+        else if (typeof val === 'object' &&
+            val != null &&
+            !platform.isFile(val)) {
+            throw new Error(`Object serialization into FormData not supported for object: ${val}`);
+        }
+        else {
+            if (platform.isFile(val)) {
+                const { file, name } = platform.getFileAndName(val);
+                formData.append(key, file, name);
+            }
+            else {
+                formData.append(key, val);
+            }
+        }
+    };
+    Object.entries(payload).forEach(([key, val]) => addProp(key, val));
+    return formData;
+};
+
+const { isArray } = Array;
+
+function fromPairs(listOfPairs){
+  const toReturn = {};
+  listOfPairs.forEach(([ prop, value ]) => toReturn[ prop ] = value);
+
+  return toReturn
+}
+
+function partitionObject(predicate, iterable){
+  const yes = {};
+  const no = {};
+  Object.entries(iterable).forEach(([ prop, value ]) => {
+    if (predicate(value, prop)){
+      yes[ prop ] = value;
+    } else {
+      no[ prop ] = value;
+    }
+  });
+
+  return [ yes, no ]
+}
+
+function partitionArray(
+  predicate, list, indexed = false
+){
+  const yes = [];
+  const no = [];
+  let counter = -1;
+
+  while (counter++ < list.length - 1){
+    if (
+      indexed ? predicate(list[ counter ], counter) : predicate(list[ counter ])
+    ){
+      yes.push(list[ counter ]);
+    } else {
+      no.push(list[ counter ]);
+    }
+  }
+
+  return [ yes, no ]
+}
+
+function partition(predicate, iterable){
+  if (arguments.length === 1){
+    return listHolder => partition(predicate, listHolder)
+  }
+  if (!isArray(iterable)) return partitionObject(predicate, iterable)
+
+  return partitionArray(predicate, iterable)
+}
+
+var flat = flatten$1;
+flatten$1.flatten = flatten$1;
+flatten$1.unflatten = unflatten;
+
+function isBuffer (obj) {
+  return obj &&
+    obj.constructor &&
+    (typeof obj.constructor.isBuffer === 'function') &&
+    obj.constructor.isBuffer(obj)
+}
+
+function keyIdentity (key) {
+  return key
+}
+
+function flatten$1 (target, opts) {
+  opts = opts || {};
+
+  const delimiter = opts.delimiter || '.';
+  const maxDepth = opts.maxDepth;
+  const transformKey = opts.transformKey || keyIdentity;
+  const output = {};
+
+  function step (object, prev, currentDepth) {
+    currentDepth = currentDepth || 1;
+    Object.keys(object).forEach(function (key) {
+      const value = object[key];
+      const isarray = opts.safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = isBuffer(value);
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
+      );
+
+      const newKey = prev
+        ? prev + delimiter + transformKey(key)
+        : transformKey(key);
+
+      if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
+        (!opts.maxDepth || currentDepth < maxDepth)) {
+        return step(value, newKey, currentDepth + 1)
+      }
+
+      output[newKey] = value;
+    });
+  }
+
+  step(target);
+
+  return output
+}
+
+function unflatten (target, opts) {
+  opts = opts || {};
+
+  const delimiter = opts.delimiter || '.';
+  const overwrite = opts.overwrite || false;
+  const transformKey = opts.transformKey || keyIdentity;
+  const result = {};
+
+  const isbuffer = isBuffer(target);
+  if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
+    return target
+  }
+
+  // safely ensure that the key is
+  // an integer.
+  function getkey (key) {
+    const parsedKey = Number(key);
+
+    return (
+      isNaN(parsedKey) ||
+      key.indexOf('.') !== -1 ||
+      opts.object
+    ) ? key
+      : parsedKey
+  }
+
+  function addKeys (keyPrefix, recipient, target) {
+    return Object.keys(target).reduce(function (result, key) {
+      result[keyPrefix + delimiter + key] = target[key];
+
+      return result
+    }, recipient)
+  }
+
+  function isEmpty (val) {
+    const type = Object.prototype.toString.call(val);
+    const isArray = type === '[object Array]';
+    const isObject = type === '[object Object]';
+
+    if (!val) {
+      return true
+    } else if (isArray) {
+      return !val.length
+    } else if (isObject) {
+      return !Object.keys(val).length
+    }
+  }
+
+  target = Object.keys(target).reduce(function (result, key) {
+    const type = Object.prototype.toString.call(target[key]);
+    const isObject = (type === '[object Object]' || type === '[object Array]');
+    if (!isObject || isEmpty(target[key])) {
+      result[key] = target[key];
+      return result
+    } else {
+      return addKeys(
+        key,
+        result,
+        flatten$1(target[key], opts)
+      )
+    }
+  }, {});
+
+  Object.keys(target).forEach(function (key) {
+    const split = key.split(delimiter).map(transformKey);
+    let key1 = getkey(split.shift());
+    let key2 = getkey(split[0]);
+    let recipient = result;
+
+    while (key2 !== undefined) {
+      if (key1 === '__proto__') {
+        return
+      }
+
+      const type = Object.prototype.toString.call(recipient[key1]);
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
+      );
+
+      // do not write over falsey, non-undefined values if overwrite is false
+      if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+        return
+      }
+
+      if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+        recipient[key1] = (
+          typeof key2 === 'number' &&
+          !opts.object ? [] : {}
+        );
+      }
+
+      recipient = recipient[key1];
+      if (split.length > 0) {
+        key1 = getkey(split.shift());
+        key2 = getkey(split[0]);
+      }
+    }
+
+    // unflatten again for 'messy objects'
+    recipient[key1] = unflatten(target[key], opts);
+  });
+
+  return result
+}
+
+/**
+ *  Brings the 1st level to the 0th level.
+ *  Flats the object by nesting with '.' path separator.
+ */
+const serializeQueryForSpringBoot = (obj) => {
+    const parts = [];
+    Object.entries(obj).forEach(([key, val]) => {
+        if (Array.isArray(val)) {
+            val.forEach((v) => {
+                parts.push([key, v]);
+            });
+        }
+        else if (typeof val === 'object') {
+            objectToParams(val).forEach(([key, val]) => {
+                parts.push([key, val.toString()]);
+            });
+        }
+        else {
+            parts.push([key, val]);
+        }
+    });
+    return parts.map((p) => `${p[0]}=${p[1]}`).join('&');
+};
+const flatten = (obj) => {
+    const r = flat.flatten(obj);
+    //   { empty: {} } would be { empty: {} } instead of empty array
+    return Object.entries(r).filter(([k, v]) => typeof v !== 'object');
+};
+const objectToParams = (obj) => {
+    const [arrayProps, nonArrayProps] = partition((e) => Array.isArray(e[1]), Object.entries(obj));
+    const withoutArrayProps = fromPairs(nonArrayProps);
+    const res = flatten(withoutArrayProps);
+    arrayProps.forEach(([k, vals]) => {
+        vals.forEach((v) => res.push([k, v]));
+    });
+    return res;
+};
+
+const noOpUrlConverter = () => ({ query, path }) => {
+    return {
+        url: path,
+        params: query,
+    };
+};
+const springBootUrlConverter = () => ({ query, path }) => {
+    return {
+        url: path + (query ? `?${serializeQueryForSpringBoot(query)}` : ''),
+        params: undefined,
+    };
+};
+const createHttpClient$1 = (axios, platform, urlConverter = noOpUrlConverter()) => {
+    return {
+        request: (req) => {
+            const { query, type, body } = req;
+            const data = type === ContentType.FormData ? convertToFormData(body, platform) : body;
+            return axios
+                .request({
+                method: req.method,
+                // url: req.path + (query ? `?${serializeQueryForNestJs(query)}` : ''),
+                // params: req.query, // TODO make this customizable as different behaviour might be needed with different APIs
+                // url: req.path,
+                ...urlConverter(req),
+                data,
+                headers: {
+                    ContentType: type,
+                },
+            })
+                .then((r) => r.data);
+        },
+    };
+};
+
+class BrowserPlatFormHelper {
+    isFile = (obj) => obj instanceof File;
+    getFileAndName = (obj) => {
+        if (!(obj instanceof File))
+            throw new Error(`Obj ${obj} is not a file`);
+        return {
+            file: obj,
+            name: obj.name,
+        };
+    };
+    isFileList = (obj) => obj instanceof FileList;
+    // @ts-ignore
+    newFormData = () => new FormData();
+}
+
+const createHttpClient = (axios, urlConverter = noOpUrlConverter()) => {
+    return createHttpClient$1(axios, new BrowserPlatFormHelper(), urlConverter);
+};
+
+export { createHttpClient, noOpUrlConverter, springBootUrlConverter };