@vulog/aima-client 1.0.5 → 1.0.6

package/.eslintrc.js

@@ -0,0 +1,112 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+        // Indicates the location of the TypeScript configuration file
+        project: 'tsconfig.json',
+        // Sets the root directory for the TypeScript configuration
+        tsconfigRootDir: __dirname,
+        // Specifies the version of ECMAScript syntax to be used
+        ecmaVersion: 'latest',
+        // Indicates the type of source code (script or module)
+        sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint', 'prettier', 'import'],
+    extends: [
+        'airbnb-base',
+        'airbnb-typescript/base',
+        'plugin:@typescript-eslint/recommended',
+        'prettier',
+        'plugin:prettier/recommended',
+    ],
+    root: true,
+    env: {
+        es6: true,
+        node: true,
+    },
+    ignorePatterns: [
+        '/dist/**/*', // Ignore built files.
+        '.eslintrc.js',
+        '**/*.test.ts',
+    ],
+    rules: {
+        // Configures the Prettier integration with ESLint
+        'prettier/prettier': ['error', { endOfLine: 'auto' }],
+        // Disables the rule requiring an 'I' prefix for interfaces
+        '@typescript-eslint/interface-name-prefix': 'off',
+        // Configures the naming conventions for various code constructs
+        '@typescript-eslint/naming-convention': [
+            // ... various naming convention configurations ...
+            'error',
+            // Allows any naming format for destructured variables
+            {
+                selector: 'variable',
+                modifiers: ['destructured'],
+                format: null,
+            },
+            // Requires strict camelCase for function names
+            {
+                selector: 'function',
+                format: ['strictCamelCase'],
+            },
+            // Requires boolean variables to have one of the specified prefixes
+            {
+                selector: 'variable',
+                format: null,
+                types: ['boolean'],
+                prefix: ['is', 'should', 'has', 'can', 'did', 'will'],
+            },
+            // Requires enum names to have a strict PascalCase format
+            {
+                selector: 'enum',
+                format: ['StrictPascalCase'],
+            },
+        ],
+        'import/extensions': 'off',
+        // Disables the rule requiring explicit return types for functions
+        '@typescript-eslint/explicit-function-return-type': 'off',
+        // Disables the rule requiring explicit boundary types for modules
+        '@typescript-eslint/explicit-module-boundary-types': 'off',
+        // Disables the rule prohibiting the use of 'any' type
+        '@typescript-eslint/no-explicit-any': 'off',
+        // Disables the rule detecting unused variables
+        'no-unused-vars': 0,
+        // Disables the rule disallowing named exports used as a default export
+        'import/no-named-as-default': 0,
+        // Configures the order and formatting of import statements
+        'import/order': [
+            // ... import order configuration ...
+            'error',
+            {
+                // Configure the alphabetization settings
+                alphabetize: {
+                    // Enforce ascending alphabetical order
+                    order: 'asc',
+                    // Do not ignore the case while sorting
+                    caseInsensitive: false,
+                },
+                // Enforce newlines between different groups and inside groups of imports
+                'newlines-between': 'always-and-inside-groups',
+                // Warn when there is an import statement that is not part of any group
+                warnOnUnassignedImports: true,
+            },
+        ],
+        // Configures the rule detecting extraneous dependencies
+        'import/no-extraneous-dependencies': [
+            // ... extraneous dependencies configuration ...
+            'error',
+            {
+                // Specify the file patterns where devDependencies imports are allowed
+                devDependencies: [
+                    // Allow devDependencies imports in test and spec files
+                    '**/*.test.{ts,js}',
+                    '**/*.spec.{ts,js}',
+                    // Allow devDependencies imports in the 'test' folder
+                    './test/**.{ts,js}',
+                    // Allow devDependencies imports in the 'scripts' folder
+                    './scripts/**/*.{ts,js}',
+                ],
+            },
+        ],
+        'import/prefer-default-export': 'off',
+    },
+};

package/dist/index.js

@@ -46,7 +46,7 @@ var formatError = (error) => {
       status,
       data
     },
-    originalError: error
+    originalError: error.toJSON ? error.toJSON() : error
   };
 };
 var getClient = (options) => {

package/dist/index.mjs

@@ -10,7 +10,7 @@ var formatError = (error) => {
       status,
       data
     },
-    originalError: error
+    originalError: error.toJSON ? error.toJSON() : error
   };
 };
 var getClient = (options) => {

package/package.json

@@ -1,13 +1,10 @@
 {
     "name": "@vulog/aima-client",
-    "version": "1.0.5",
+    "version": "1.0.6",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
-    "files": [
-        "dist",
-        "README.md"
-    ],
+
     "scripts": {
         "build": "tsup",
         "dev": "tsup --watch",

package/src/getClient.test.ts

@@ -0,0 +1,21 @@
+import { describe, test, vi, beforeEach, expect } from 'vitest';
+import getClient from './getClient';
+import { ClientOptions } from './types';
+
+describe('getClient', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+
+    test('create client', () => {
+        const options: ClientOptions = {
+            fleetId: 'fleetId',
+            baseUrl: 'baseUrl',
+            clientId: 'clientId',
+            clientSecret: 'clientSecret',
+            apiKey: 'apiKey',
+        };
+        const client = getClient(options);
+        expect(client.defaults.baseURL).toEqual(options.baseUrl);
+    });
+});

package/src/getClient.ts

@@ -0,0 +1,156 @@
+import axios from 'axios';
+import _ from 'lodash';
+import { LRUCache } from 'lru-cache';
+
+import { Client, ClientError, ClientOptions } from './types';
+
+const clientCache = new LRUCache<
+    string,
+    {
+        options: ClientOptions;
+        client: Client;
+    }
+>({ max: 100 });
+
+const formatError = (error: any): ClientError => {
+    const { response: { status, data } = { status: 500 } } = error ?? {};
+
+    return {
+        formattedError: {
+            status,
+            data,
+        },
+        originalError: error.toJSON ? error.toJSON() : error,
+    };
+};
+
+const getClient = (options: ClientOptions): Client => {
+    if (clientCache.has(options.name ?? options.fleetId)) {
+        const { options: cachedOptions, client } = clientCache.get(options.fleetId)!;
+        if (_.isEqual(cachedOptions, options)) {
+            return client;
+        }
+    }
+
+    const client = axios.create({
+        baseURL: _.trimEnd(options.baseUrl, '/'),
+        timeout: 30000,
+        headers: {
+            'Cache-Control': 'no-cache',
+            'Content-Type': 'application/json',
+            'X-Api-Key': options.apiKey,
+        },
+        withCredentials: false,
+    }) as Client;
+
+    const clientCredentialsAuthentification = async (): Promise<string> => {
+        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.post(
+            `${_.trimEnd(options.baseUrl, '/')}/auth/realms/${options.fleetMaster ?? options.fleetId}/protocol/openid-connect/token`,
+            params,
+            {
+                timeout: 30000,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                withCredentials: false,
+            }
+        );
+        client.defaults.headers.Authorization = `Bearer ${token.access_token}`;
+        return token.access_token;
+    };
+
+    const refreshTokenAuthentification = async (): Promise<string> => {
+        if (!client.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', client.refreshToken);
+
+        const { data: token } = await axios.post(
+            `${_.trimEnd(options.baseUrl, '/')}/auth/realms/${options.fleetMaster ?? options.fleetId}/protocol/openid-connect/token`,
+            params,
+            {
+                timeout: 30000,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                withCredentials: false,
+            }
+        );
+        client.defaults.headers.Authorization = `Bearer ${token.access_token}`;
+        client.refreshToken = token.refresh_token;
+        return token.access_token;
+    };
+
+    client.signInWithPassword = async (username: string, password: string): Promise<void> => {
+        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.post(
+            `${_.trimEnd(options.baseUrl, '/')}/auth/realms/${options.fleetMaster ?? options.fleetId}/protocol/openid-connect/token`,
+            params,
+            {
+                timeout: 30000,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                withCredentials: false,
+            }
+        );
+        client.defaults.headers.Authorization = `Bearer ${token.access_token}`;
+        client.refreshToken = token.refresh_token;
+    };
+
+    client.interceptors.response.use(
+        (response) => response,
+        (error) => {
+            const { config, response: { status } = { status: 500 } } = error;
+            const originalRequest = config;
+
+            if (originalRequest.attemptCount === undefined) {
+                originalRequest.attemptCount = 0;
+            }
+
+            if (originalRequest.attemptCount === 5) {
+                return Promise.reject(formatError(error));
+            }
+
+            if (status === 401) {
+                return new Promise((resolve, reject) => {
+                    (options.secure ? refreshTokenAuthentification() : clientCredentialsAuthentification())
+                        .then((token) => {
+                            originalRequest.headers.Authorization = `Bearer ${token}`;
+                            resolve(client.request(originalRequest));
+                        })
+                        .catch(() => reject(formatError(error)));
+                });
+            }
+
+            return Promise.reject(formatError(error));
+        }
+    );
+
+    clientCache.set(options.name ?? options.fleetId, { options, client });
+
+    return client;
+};
+
+export default getClient;

package/src/index.ts

@@ -0,0 +1,4 @@
+import getClient from './getClient';
+import { ClientOptions } from './types';
+
+export { ClientOptions, getClient };

package/src/types.ts

@@ -0,0 +1,25 @@
+import { AxiosInstance } from 'axios';
+
+export type ClientOptions = {
+    fleetId: string;
+    name?: string;
+    fleetMaster?: string;
+    baseUrl: string;
+    clientId: string;
+    clientSecret: string;
+    apiKey: string;
+    secure?: boolean;
+};
+
+export type ClientError = {
+    formattedError: {
+        status: number;
+        data: any;
+    };
+    originalError: any;
+};
+
+export type Client = AxiosInstance & {
+    refreshToken?: string;
+    signInWithPassword: (username: string, password: string) => Promise<void>;
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "include": ["src"],
+    "exclude": ["**/*.test.ts"],
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "esnext",
+        "lib": ["esnext"],
+        "declaration": true,
+        "strict": true,
+        "moduleResolution": "node",
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "outDir": "dist",
+        "rootDir": "src"
+    }
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    clean: true,
+    format: ['cjs', 'esm'],
+    dts: true,
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+    },
+});