@vulog/aima-client 1.2.30 → 1.2.31

package/dist/index.cjs

@@ -0,0 +1,281 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let axios = require("axios");
+axios = __toESM(axios);
+let es_toolkit = require("es-toolkit");
+let lru_cache = require("lru-cache");
+//#region src/CurlHelper.ts
+var CurlHelper = class {
+	request;
+	constructor(config) {
+		this.request = config;
+	}
+	getHeaders() {
+		let { headers } = this.request;
+		let curlHeaders = "";
+		if (headers.hasOwnProperty("common")) headers = this.request.headers[this.request.method];
+		for (const property in this.request.headers) if (![
+			"common",
+			"delete",
+			"get",
+			"head",
+			"patch",
+			"post",
+			"put"
+		].includes(property)) headers[property] = this.request.headers[property];
+		for (const property in headers) if ({}.hasOwnProperty.call(headers, property)) {
+			const header = `${property}:${headers[property]}`;
+			curlHeaders = `${curlHeaders} -H '${header}'`;
+		}
+		return curlHeaders.trim();
+	}
+	getMethod() {
+		return `-X ${this.request.method.toUpperCase()}`;
+	}
+	getBody() {
+		if (typeof this.request.data !== "undefined" && this.request.data !== "" && this.request.data !== null && this.request.method.toUpperCase() !== "GET") return `--data '${typeof this.request.data === "object" || Object.prototype.toString.call(this.request.data) === "[object Array]" ? JSON.stringify(this.request.data) : this.request.data}'`.trim();
+		return "";
+	}
+	getUrl() {
+		if (this.request.baseURL) {
+			const baseUrl = this.request.baseURL;
+			const { url } = this.request;
+			return (url.startsWith("http") ? url : `${baseUrl}/${url}`).replace(/\/{2,}/g, "/").replace("http:/", "http://").replace("https:/", "https://");
+		}
+		return this.request.url;
+	}
+	getQueryString() {
+		if (this.request.paramsSerializer) {
+			const params = this.request.paramsSerializer(this.request.params);
+			if (!params || params.length === 0) return "";
+			if (params.startsWith("?")) return params;
+			return `?${params}`;
+		}
+		let params = "";
+		let i = 0;
+		for (const param in this.request.params) if ({}.hasOwnProperty.call(this.request.params, param)) {
+			params += i !== 0 ? `&${param}=${this.request.params[param]}` : `?${param}=${this.request.params[param]}`;
+			i += 1;
+		}
+		return params;
+	}
+	getBuiltURL() {
+		let url = this.getUrl();
+		if (this.getQueryString() !== "") url += this.getQueryString();
+		return url.trim();
+	}
+	generateCommand() {
+		return `curl ${this.getMethod()} "${this.getBuiltURL()}" ${this.getHeaders()} ${this.getBody()}`.trim().replace(/\s{2,}/g, " ");
+	}
+};
+//#endregion
+//#region src/getClient.ts
+const clientCache = new lru_cache.LRUCache({ max: 100 });
+const tokenCache = new lru_cache.LRUCache({ max: 100 });
+const getMemoryStore = (options) => ({
+	getToken: async () => {
+		const log = options.onLog ?? console.log;
+		log("getMemoryStore.getToken", options.name ?? options.fleetId);
+		if (tokenCache.has(options.name ?? options.fleetId)) {
+			log("getMemoryStore.getToken", tokenCache.get(options.name ?? options.fleetId));
+			return tokenCache.get(options.name ?? options.fleetId);
+		}
+	},
+	setToken: async (token) => {
+		(options.onLog ?? console.log)("getMemoryStore.setToken", options.name ?? options.fleetId, token);
+		tokenCache.set(options.name ?? options.fleetId, token);
+	}
+});
+const formatError = (error) => {
+	if (error instanceof axios.AxiosError) return {
+		originalError: error.toJSON(),
+		formattedError: {
+			status: error.response?.status ?? error.status,
+			data: error.response?.data,
+			message: error.message
+		}
+	};
+	return {
+		formattedError: {},
+		originalError: JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)))
+	};
+};
+const getClient = (options) => {
+	if (clientCache.has(options.name ?? options.fleetId)) {
+		const { options: cachedOptions, client } = clientCache.get(options.fleetId);
+		if ((0, es_toolkit.isEqual)(cachedOptions, options)) return client;
+	}
+	const client = axios.default.create({
+		baseURL: (0, es_toolkit.trimEnd)(options.baseUrl, "/"),
+		timeout: 3e4,
+		headers: {
+			"Cache-Control": "no-cache",
+			"Content-Type": "application/json",
+			"X-Api-Key": options.apiKey,
+			"User-Agent": options.userAgent ?? `aima-node/1.2.31 ${options.fleetId}`
+		},
+		withCredentials: false
+	});
+	client.clientOptions = options;
+	const clientCredentialsAuthentification = async () => {
+		const params = new URLSearchParams();
+		params.append("client_id", options.clientId);
+		params.append("client_secret", options.clientSecret);
+		params.append("securityOptions", "SSL_OP_NO_SSLv3");
+		params.append("grant_type", "client_credentials");
+		const { data: token } = await axios.default.post(`${(0, es_toolkit.trimEnd)(options.baseUrl, "/")}/auth/realms/${options.fleetMaster ?? options.fleetId}/protocol/openid-connect/token`, params, {
+			timeout: 3e4,
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			withCredentials: false
+		});
+		await (options.store ?? getMemoryStore(options)).setToken({
+			accessToken: token.access_token,
+			refreshToken: token.refresh_token
+		});
+		return token.access_token;
+	};
+	const refreshTokenAuthentification = async () => {
+		const store = options.store ?? getMemoryStore(options);
+		const oldToken = await store.getToken();
+		if (!oldToken?.refreshToken) throw new Error("No refresh token available");
+		const params = new URLSearchParams();
+		params.append("client_id", options.clientId);
+		params.append("client_secret", options.clientSecret);
+		params.append("securityOptions", "SSL_OP_NO_SSLv3");
+		params.append("grant_type", "refresh_token");
+		params.append("refresh_token", oldToken.refreshToken);
+		const { data: token } = await axios.default.post(`${(0, es_toolkit.trimEnd)(options.baseUrl, "/")}/auth/realms/${options.fleetMaster ?? options.fleetId}/protocol/openid-connect/token`, params, {
+			timeout: 3e4,
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			withCredentials: false
+		});
+		await store.setToken({
+			accessToken: token.access_token,
+			refreshToken: token.refresh_token
+		});
+		return token.access_token;
+	};
+	client.signInWithPassword = async (username, password) => {
+		if (!options.secure) throw new Error("Not secure");
+		const params = new URLSearchParams();
+		params.append("client_id", options.clientId);
+		params.append("client_secret", options.clientSecret);
+		params.append("securityOptions", "SSL_OP_NO_SSLv3");
+		params.append("grant_type", "password");
+		params.append("username", username);
+		params.append("password", password);
+		const { data: token } = await axios.default.post(`${(0, es_toolkit.trimEnd)(options.baseUrl, "/")}/auth/realms/${options.fleetMaster ?? options.fleetId}/protocol/openid-connect/token`, params, {
+			timeout: 3e4,
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			withCredentials: false
+		});
+		const newToken = {
+			accessToken: token.access_token,
+			refreshToken: token.refresh_token
+		};
+		await (options.store ?? getMemoryStore(options)).setToken(newToken);
+		return newToken;
+	};
+	client.interceptors.request.use(async (request) => {
+		const newRequest = request;
+		const token = await (options.store ?? getMemoryStore(options)).getToken();
+		if (token?.accessToken) newRequest.headers.Authorization = `Bearer ${token.accessToken}`;
+		if (options.logCurl) {
+			const curl = new CurlHelper(newRequest).generateCommand();
+			if (options.onLog) options.onLog({
+				curl,
+				message: "getClient > Curl command"
+			});
+			else console.log({
+				curl,
+				message: "getClient > Curl command"
+			});
+		}
+		return newRequest;
+	});
+	let isRefreshing = false;
+	let refreshSubscribers = [];
+	const executorRefresh = (config) => {
+		return new Promise((resolve, reject) => {
+			refreshSubscribers.push((token, error) => {
+				if (error) {
+					reject(formatError(error));
+					return;
+				}
+				resolve(client.request(config));
+			});
+		});
+	};
+	client.interceptors.response.use((response) => {
+		if (options.logResponse) {
+			const finalUrl = new CurlHelper(response.config).getBuiltURL();
+			const { data, headers } = response;
+			const dataLog = response.config.responseType !== "arraybuffer" && response.config.responseType !== "blob" ? data : "ArrayBuffer or blob";
+			if (options.onLog) options.onLog({
+				finalUrl,
+				data: dataLog,
+				headers,
+				message: "getClient > Response"
+			});
+			else console.log({
+				finalUrl,
+				data: dataLog,
+				headers,
+				message: "getClient > Response"
+			});
+		}
+		return response;
+	}, (error) => {
+		const { config, response: { status } = { status: 500 } } = error;
+		const originalRequest = config;
+		if (originalRequest.attemptCount === void 0) originalRequest.attemptCount = 0;
+		if (originalRequest.attemptCount === 5) return Promise.reject(formatError(error));
+		if (status === 401) {
+			originalRequest.attemptCount += 1;
+			if (!isRefreshing) {
+				isRefreshing = true;
+				let authentification;
+				if (options.secure) authentification = refreshTokenAuthentification;
+				else authentification = clientCredentialsAuthentification;
+				authentification().then((accessToken) => {
+					refreshSubscribers.forEach((cb) => cb(accessToken));
+				}).catch((errorAuth) => {
+					refreshSubscribers.forEach((cb) => cb(void 0, errorAuth));
+				}).finally(() => {
+					isRefreshing = false;
+					refreshSubscribers = [];
+				});
+			}
+			return executorRefresh(originalRequest);
+		}
+		return Promise.reject(formatError(error));
+	});
+	clientCache.set(options.name ?? options.fleetId, {
+		options,
+		client
+	});
+	return client;
+};
+//#endregion
+exports.getClient = getClient;

package/dist/index.d.cts

@@ -0,0 +1,43 @@
+import { AxiosInstance } from "axios";
+
+//#region src/types.d.ts
+type Token = {
+  accessToken: string;
+  refreshToken: string;
+};
+type Store = {
+  getToken: () => Promise<Token | undefined>;
+  setToken: (token: Token) => Promise<void>;
+};
+type ClientOptions = {
+  fleetId: string;
+  name?: string;
+  fleetMaster?: string;
+  baseUrl: string;
+  clientId: string;
+  clientSecret: string;
+  apiKey: string;
+  secure?: boolean;
+  logCurl?: boolean;
+  logResponse?: boolean;
+  store?: Store;
+  onLog?: (...args: any[]) => void;
+  userAgent?: string;
+};
+type ClientError = {
+  formattedError: {
+    status?: number;
+    data?: any;
+    message?: string;
+  };
+  originalError: any;
+};
+type Client = AxiosInstance & {
+  signInWithPassword: (username: string, password: string) => Promise<Token>;
+  clientOptions: ClientOptions;
+};
+//#endregion
+//#region src/getClient.d.ts
+declare const getClient: (options: ClientOptions) => Client;
+//#endregion
+export { type Client, type ClientError, type ClientOptions, type Store, type Token, getClient };

package/dist/index.d.mts

@@ -1,41 +1,43 @@
-import { AxiosInstance } from 'axios';
+import { AxiosInstance } from "axios";
 
+//#region src/types.d.ts
 type Token = {
-    accessToken: string;
-    refreshToken: string;
+  accessToken: string;
+  refreshToken: string;
 };
 type Store = {
-    getToken: () => Promise<Token | undefined>;
-    setToken: (token: Token) => Promise<void>;
+  getToken: () => Promise<Token | undefined>;
+  setToken: (token: Token) => Promise<void>;
 };
 type ClientOptions = {
-    fleetId: string;
-    name?: string;
-    fleetMaster?: string;
-    baseUrl: string;
-    clientId: string;
-    clientSecret: string;
-    apiKey: string;
-    secure?: boolean;
-    logCurl?: boolean;
-    logResponse?: boolean;
-    store?: Store;
-    onLog?: (...args: any[]) => void;
-    userAgent?: string;
+  fleetId: string;
+  name?: string;
+  fleetMaster?: string;
+  baseUrl: string;
+  clientId: string;
+  clientSecret: string;
+  apiKey: string;
+  secure?: boolean;
+  logCurl?: boolean;
+  logResponse?: boolean;
+  store?: Store;
+  onLog?: (...args: any[]) => void;
+  userAgent?: string;
 };
 type ClientError = {
-    formattedError: {
-        status?: number;
-        data?: any;
-        message?: string;
-    };
-    originalError: any;
+  formattedError: {
+    status?: number;
+    data?: any;
+    message?: string;
+  };
+  originalError: any;
 };
 type Client = AxiosInstance & {
-    signInWithPassword: (username: string, password: string) => Promise<Token>;
-    clientOptions: ClientOptions;
+  signInWithPassword: (username: string, password: string) => Promise<Token>;
+  clientOptions: ClientOptions;
 };
-
+//#endregion
+//#region src/getClient.d.ts
 declare const getClient: (options: ClientOptions) => Client;
-
-export { type Client, type ClientError, type ClientOptions, type Store, type Token, getClient };
+//#endregion
+export { type Client, type ClientError, type ClientOptions, type Store, type Token, getClient };