@fluxo-dev/api-client-base 0.0.8

package/.babelrc

@@ -0,0 +1,12 @@
+{
+  "presets": [
+    [
+      "@nx/react/babel",
+      {
+        "runtime": "automatic",
+        "useBuiltIns": "usage"
+      }
+    ]
+  ],
+  "plugins": []
+}

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+  "extends": ["plugin:@nx/react", "../../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,7 @@
+# libs/shared/api-client-base
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test libs/shared/api-client-base` to execute the unit tests via [Jest](https://jestjs.io).

package/jest.config.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+export default {
+  displayName: 'libs/shared/api-client-base',
+  preset: '../../../jest.preset.js',
+  transform: {
+    '^(?!.*\\.(js|jsx|ts|tsx|css|json)$)': '@nx/react/plugins/jest',
+    '^.+\\.[tj]sx?$': ['babel-jest', { presets: ['@nx/react/babel'] }],
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
+  coverageDirectory: '../../../coverage/libs/shared/api-client-base',
+};

package/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@fluxo-dev/api-client-base",
+  "version": "0.0.8",
+  "type": "commonjs",
+  "peerDependencies": {
+    "@fluxo-dev/state": "^0.0.8"
+  }
+}

package/project.json

@@ -0,0 +1,43 @@
+{
+  "name": "libs/shared/api-client-base",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/shared/api-client-base/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["libs/shared/api-client-base/**/*.{ts,tsx,js,jsx}"]
+      }
+    },
+    "build": {
+      "executor": "@nx/rollup:rollup",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/shared/api-client-base",
+        "tsConfig": "libs/shared/api-client-base/tsconfig.lib.json",
+        "project": "libs/shared/api-client-base/package.json",
+        "entryFile": "libs/shared/api-client-base/src/index.ts",
+        "external": ["react", "react-dom", "react/jsx-runtime"],
+        "rollupConfig": "@nx/react/plugins/bundle-rollup",
+        "compiler": "babel",
+        "assets": [
+          {
+            "glob": "libs/shared/api-client-base/README.md",
+            "input": ".",
+            "output": "."
+          }
+        ]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "libs/shared/api-client-base/jest.config.ts"
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,39 @@
+export * from './lib/fluxo-client';
+export * from './lib/fluxo-client-base-sys';
+export * from './lib/fluxo-state-dispatcher';
+export * from './lib/interfaces';
+
+export * from './lib/http-client/http-client';
+export * from './lib/fluxo-client-interface';
+
+/* Documentation */
+export * from './lib/korebi/documentation';
+
+/* Configuration */
+export * from './lib/configuration/index';
+
+/* Reporting */
+export * from './lib/reporting/index';
+
+/* Printing */
+export * from './lib/printing/index';
+
+/* Workflow */
+export * from './lib/workflow/index';
+
+/* Security Models */
+export * from './lib/security/user';
+export * from './lib/security/apikey';
+export * from './lib/security/domain-role';
+export * from './lib/security/permission';
+export * from './lib/security/route-rule';
+
+/* Korebi */
+export * from './lib/korebi';
+
+/* Apps */
+export * from './lib/apps';
+
+/* Utils */
+export * from './lib/utils';
+export * from './lib/infrastructure';

package/src/lib/apps/apps.service.ts

@@ -0,0 +1,46 @@
+import {FluxoApp} from "./models/fluxo-app";
+import {HttpClient} from "../http-client/http-client";
+import {FluxoEmbeddedModuleConfiguration} from "./models";
+
+export class AppService {
+
+  getApps(onlyDeployed: boolean): Promise<FluxoApp[]> {
+
+    const url = onlyDeployed ? 'apps?onlyDeployed=true' : 'apps';
+
+    return HttpClient.Instance().client.get(url);
+  }
+
+  activateApp(appId: number): Promise<any> {
+    return HttpClient.Instance().client.post(`apps/${appId}/activate`, {});
+  }
+
+  deactivateApp(appId: number): Promise<any> {
+    return HttpClient.Instance().client.post(`apps/${appId}/deactivate`, {});
+  }
+
+  installApp(data: any): Promise<any> {
+    return HttpClient.Instance().client.post(`apps/install`, data, {
+      headers: {
+        "Content-Type": "multipart/form-data",
+      },
+    });
+  }
+
+  upgradeApp(appId: number, data: any): Promise<any> {
+    return HttpClient.Instance().client.post(`apps/${appId}/upgrade`, data, {
+      headers: {
+        "Content-Type": "multipart/form-data",
+      },
+    });
+  }
+
+  uninstallApp(appId: number): Promise<any> {
+    return HttpClient.Instance().client.delete(`apps/${appId}/uninstall`);
+  }
+
+  installEmbeddedModule(data: FluxoEmbeddedModuleConfiguration): Promise<void> {
+    return HttpClient.Instance().client.post(`apps/install/embedded`, data);
+  }
+
+}

package/src/lib/apps/index.ts

@@ -0,0 +1,2 @@
+export * from './apps.service';
+export * from './models/index';

package/src/lib/apps/models/app-state.ts

@@ -0,0 +1,4 @@
+export enum AppState {
+  Active,
+  Inactive
+}

package/src/lib/apps/models/app-type.ts

@@ -0,0 +1,4 @@
+export enum AppType {
+  Frontend,
+  Backend
+}

package/src/lib/apps/models/embedded-module.ts

@@ -0,0 +1,106 @@
+import {FluxoEmbeddedModuleConfiguration} from "./fluxo-embedded-module-configuration";
+import {IndexRouteObject, LazyRouteFunction, NonIndexRouteObject, RouteObject} from "react-router-dom";
+import {FluxoAppMenu} from "./fluxo-app-menu";
+
+export class EmbeddedModule {
+
+  public get name(): string {
+    return this._name;
+  }
+
+  public get description(): string {
+    return this._description;
+  }
+
+  public get author(): string {
+    return this._author;
+  }
+
+  public get version(): string {
+    return this._version;
+  }
+
+  public get scope(): string {
+    return this._scope;
+  }
+
+  public get navigation(): EmbeddedModuleNavigation[] {
+    return this._navigation;
+  }
+
+  private readonly _name: string
+  private readonly _description: string
+  private readonly _author: string
+  private readonly _version: string
+  private readonly _scope: string
+  private _navigation: EmbeddedModuleNavigation[] = [];
+
+  constructor(name: string, description: string, author: string, version: string, scope: string) {
+    this._name = name;
+    this._description = description;
+    this._author = author;
+    this._version = version;
+    this._scope = scope;
+  }
+
+  public attachNavigation(navigationConfig: EmbeddedModuleNavigation): void {
+    this._navigation.push(navigationConfig);
+  }
+
+  public getRouteObject(routes: EmbeddedModuleRoute[] | undefined = undefined): RouteObject[] {
+    const r = routes ?? this._navigation.map(a => a.routes).map(a => a).flat();
+
+    if(!r || r.length === 0) return [];
+
+    const routeObject: RouteObject[] = [];
+
+    r.map((route: EmbeddedModuleRoute) => {
+      if (route.route) {
+
+        let path = route.route;
+
+        if(route.route === '/') {
+          path = '';
+        }
+
+        if(route.route === "*") {
+          path = '*';
+        }
+
+        routeObject.push({
+          path: path,
+          index: route.route === '/' ? undefined : false,
+          element: route.component,
+          children: (route.routes && route.routes.length > 0) ? this.getRouteObject(route.routes) : [],
+        });
+      }
+    });
+
+    return routeObject;
+  }
+
+  public getEmbeddedModule(): FluxoEmbeddedModuleConfiguration {
+
+    const conf: FluxoEmbeddedModuleConfiguration = {
+      name: this._name,
+      description: this._description,
+      author: this._author,
+      version: this._version,
+      scope: this._scope,
+      menu: this._navigation.map(a => a.menu)
+    }
+
+    return conf;
+  }
+}
+
+export interface EmbeddedModuleNavigation {
+  menu: FluxoAppMenu;
+  routes: EmbeddedModuleRoute[];
+}
+
+export interface EmbeddedModuleRoute {
+  route?: string;
+  component?: any,
+  routes?: EmbeddedModuleRoute[];
+}

package/src/lib/apps/models/fluxo-app-menu.ts

@@ -0,0 +1,12 @@
+export interface FluxoAppMenu {
+  identifier: string;
+  name: string;
+  route?: string;
+  items?: FluxoAppMenuItem[];
+}
+
+export interface FluxoAppMenuItem {
+  identifier: string;
+  name: string;
+  route?: string;
+}

package/src/lib/apps/models/fluxo-app.ts

@@ -0,0 +1,17 @@
+import {AppType} from "./app-type";
+import {AppState} from "./app-state";
+
+export interface FluxoApp {
+  id: number;
+  name: string;
+  type: AppType;
+  description: string;
+  author: string;
+  scope: string;
+  state: AppState;
+  installationDirectory: string;
+  installationDate: Date;
+  version: string;
+  isEmbedded: boolean;
+}
+

package/src/lib/apps/models/fluxo-embedded-module-configuration.ts

@@ -0,0 +1,10 @@
+import {FluxoAppMenu} from "./fluxo-app-menu";
+
+export interface FluxoEmbeddedModuleConfiguration {
+  name: string
+  description: string
+  author: string
+  version: string
+  scope: string
+  menu: FluxoAppMenu[]
+}

package/src/lib/apps/models/fluxo-frontend-app-configuration.ts

@@ -0,0 +1,12 @@
+import {FluxoApp} from "./fluxo-app";
+import {FluxoAppMenu} from "./fluxo-app-menu";
+
+export interface FluxoFrontendAppConfiguration extends FluxoApp {
+  name: string
+  description: string
+  author: string
+  version: string
+  scope: string
+  menu: FluxoAppMenu[]
+}
+

package/src/lib/apps/models/flx-app-routes.ts

@@ -0,0 +1,5 @@
+import {FlxRoute} from "./flx-route";
+
+export interface FlxAppRoutes {
+  routes: FlxRoute[]
+}

package/src/lib/apps/models/flx-route.ts

@@ -0,0 +1,6 @@
+export interface FlxRoute {
+  path: string;
+  element: React.ReactNode,
+  permissions?: string[];
+  permissionStrategy?: 'all' | 'any';
+}

package/src/lib/apps/models/index.ts

@@ -0,0 +1,9 @@
+export * from './app-type';
+export * from './app-state';
+export * from './fluxo-app';
+export * from './fluxo-frontend-app-configuration';
+export * from './fluxo-app-menu';
+export {FluxoEmbeddedModuleConfiguration} from "./fluxo-embedded-module-configuration";
+export * from "./embedded-module";
+export * from "./flx-app-routes";
+export * from "./flx-route";

package/src/lib/auth/auth-service.ts

@@ -0,0 +1,149 @@
+import jwt_decode from "jwt-decode";
+import {LocalStorageConstants} from "../constants/local-storage";
+import {HttpClient} from "../http-client/http-client";
+import {FluxoStateDispatcher} from "../fluxo-state-dispatcher";
+
+export class AuthService {
+
+  public constructor() {
+    RefreshTokenManager.Init(this.refreshToken, this.logout);
+  }
+
+  public async setup() {
+    await this.tryAutoLogin();
+  }
+
+  private async tryAutoLogin() {
+    const accessToken = localStorage.getItem(LocalStorageConstants.accessToken);
+    if(accessToken) {
+      const decoded: any = jwt_decode(accessToken);
+
+      if(!decoded) {
+        this.logout();
+        return;
+      }
+
+      if(decoded.exp <= new Date().getTime() / 1000) {
+
+        await this.refreshToken();
+
+      } else {
+        // Avvio il timeout indicando il tempo di attesa come scadenza token - 30 secondi.
+        // pertanto, 30 secondi prima della scadenza del token, Fluxo richiederà un nuovo token grazie al refresh token.
+        RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime()! - 30000);
+      }
+
+      FluxoStateDispatcher. dispatchAutoLoginSucceded(localStorage.getItem(LocalStorageConstants.userData));
+
+    }
+  }
+
+  public async login(username: string, password: string): Promise<any> {
+    try {
+
+      const data = await HttpClient.Instance().client.post('/identity/authenticate', {username, password}, {withCredentials: true});
+
+
+      localStorage.setItem(LocalStorageConstants.accessToken, (data as any).token);
+      localStorage.setItem(LocalStorageConstants.userData, JSON.stringify((data as any).userData));
+
+      RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime()! - 60);
+
+      FluxoStateDispatcher.dispatchUserLogin({data})
+    }
+    catch(err) {
+      FluxoStateDispatcher.dispatchUserLogin(null)
+    }
+  }
+
+  public logout() {
+    RefreshTokenManager.Instance.stop();
+
+    localStorage.removeItem(LocalStorageConstants.accessToken);
+    localStorage.removeItem(LocalStorageConstants.userData);
+    FluxoStateDispatcher.dispatchUserLogout();
+  }
+
+  public async refreshToken(): Promise<any> {
+
+    try {
+
+      const data = await HttpClient.Instance().client.post('/identity/refresh-token', {}, {withCredentials: true});
+
+      localStorage.setItem(LocalStorageConstants.accessToken, (data as any).token);
+      localStorage.setItem(LocalStorageConstants.userData, JSON.stringify((data as any).userData));
+
+      RefreshTokenManager.Instance.stop();
+      RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime()! - 10000);
+
+    } catch(err) {
+      localStorage.removeItem(LocalStorageConstants.accessToken);
+      localStorage.removeItem(LocalStorageConstants.userData);
+      this.logout();
+    }
+  }
+
+  public static getJwtTokenRemainingLifetime(): number | null {
+    const token = localStorage.getItem(LocalStorageConstants.accessToken);
+
+    if(!token) {
+      throw new Error('Called getJwtTokenRemainingLifetime but no access token found');
+    }
+
+    const decoded: any = jwt_decode(token);
+    const exp: number = +decoded.exp;
+
+    const dateNow = new Date(Date.now()).getTime();
+    const diff = ((exp * 1000) - dateNow);
+
+    return diff <= 0 ? 0 : diff;
+  }
+}
+
+class RefreshTokenManager {
+  private static _instance: RefreshTokenManager;
+  private _refreshTokenInterval: any;
+  private _actionOnTimeout: () => void;
+  private _onErrorCallback: () => void;
+
+  event = new Event('build');
+
+  private constructor(action: () => void, onErrorCallback: () => void) {
+    this._refreshTokenInterval = null;
+    this._actionOnTimeout = action;
+    this._onErrorCallback = onErrorCallback;
+  }
+
+  public static Init(actionOnTimeout: () => void, onErrorCallback: () => void) {
+    this._instance = new this(actionOnTimeout, onErrorCallback);
+  }
+
+  public static get Instance() {
+
+    if(!this._instance)
+      throw new Error('RefreshTokenManager not initialized');
+
+    return this._instance;
+  }
+
+  public start(timeoutMs: number) {
+
+    console.info('   - start refresh token:' +  timeoutMs + 'ms');
+
+    if(this._actionOnTimeout === undefined)
+      throw new Error('RefreshTokenManager not initialized');
+
+    this._refreshTokenInterval = setTimeout(async () => {
+      try{
+        await this._actionOnTimeout();
+      }catch(err) {
+        this._onErrorCallback();
+      }
+    }, timeoutMs);
+  }
+
+  public stop() {
+    console.info('   - stop refresh token');
+    clearInterval(this._refreshTokenInterval);
+  }
+}

package/src/lib/configuration/app-menu-create-command.ts

@@ -0,0 +1,9 @@
+import {AppMenuContextType} from "./app-menu";
+
+export interface AppMenuCreateCommand {
+  contextType: AppMenuContextType;
+  domainRoleId?: number | null;
+  userId?: string | null;
+  name: string;
+  copyItemsFromWebMenuId: number;
+}

package/src/lib/configuration/app-menu-item.ts

@@ -0,0 +1,14 @@
+export interface AppMenuItem {
+  id?: number,
+  routerLink?: string,
+  label: string,
+  hasIndex?: boolean,
+  children?: AppMenuItem[],
+  icon?: string
+  featureIdentifier: string,
+  isGroup: boolean,
+  menuItemId?: number,
+  hasPermissions?: boolean,
+  permissions?: string[],
+  isProtectedByRule?: boolean,
+}

package/src/lib/configuration/app-menu.ts

@@ -0,0 +1,15 @@
+export interface AppMenu {
+  id: number;
+  name: string;
+  contextType: AppMenuContextType;
+  domainRoleId: number;
+  domainRoleName: string;
+  userId: string;
+  userFullName: string;
+}
+
+export enum AppMenuContextType {
+  Default,
+  DomainRole,
+  User
+}

package/src/lib/configuration/client-ui.ts

@@ -0,0 +1,5 @@
+export interface ClientUi {
+  logo: string;
+  logoHeight: number;
+  colors: string[],
+}

package/src/lib/configuration/configuration.service.ts

@@ -0,0 +1,57 @@
+import {HttpClient} from "../http-client/http-client";
+import { AppMenuItem } from "./app-menu-item";
+import { ClientUi } from "./client-ui";
+import {FeatureList} from "./models/feature-list";
+import {FluxoApp} from "../apps/models/fluxo-app";
+import {DomainRole} from "../security/domain-role/index";
+import {RouteRuleWithPermissions} from "../security/route-rule/index";
+import {Permission} from "../security/permission/index";
+import {AppMenu} from "./app-menu";
+import {AppMenuCreateCommand} from "./app-menu-create-command";
+
+export class ConfigurationService {
+
+  getInitialConfiguration(): Promise<{apps: FluxoApp[], menu: AppMenuItem[], features: FeatureList, ui: ClientUi, domainRoles: DomainRole[], permissions: any[], routeRules: RouteRuleWithPermissions[], isFluxoConfigured: boolean }> {
+    return HttpClient.Instance().client.get('client/initial');
+  }
+
+  getClientUi(): Promise<ClientUi> {
+    return HttpClient.Instance().client.get('client/ui');
+  }
+
+  updateClientUi(clientUI: ClientUi): Promise<ClientUi> {
+    return HttpClient.Instance().client.post('client/ui', clientUI);
+  }
+
+  getSystemFeatures(): Promise<FeatureList> {
+    return HttpClient.Instance().client.get('features/web')
+  }
+
+  saveAppMenu(webMenuId: number, menu: AppMenuItem[]): Promise<any> {
+    return HttpClient.Instance().client.post(`client/menu/${webMenuId}/webapp`, menu);
+  }
+
+  createAppMenu(menu: AppMenuCreateCommand): Promise<any> {
+    return HttpClient.Instance().client.post('client/menu/webapp', menu);
+  }
+
+  getAppMenuList(): Promise<AppMenu[]> {
+    return HttpClient.Instance().client.get('webmenu?includes=DomainRole,User');
+  }
+
+  getAppMenu(webMenuId: number): Promise<AppMenuItem[]> {
+    return HttpClient.Instance().client.get(`client/menu/${webMenuId}/webapp`);
+  }
+
+  public getMenuItemPermissions(domainRoleId: string): Promise<Permission[]> {
+    return HttpClient.Instance().client.get(`webmenuitem/${domainRoleId}/permissions`);
+  }
+
+  public addMenuItemPermission(domainRoleId: number, permissionId: number): Promise<void> {
+    return HttpClient.Instance().client.post(`webmenuitem/${domainRoleId}/permissions`, {domainRoleId: domainRoleId, permissionId: permissionId});
+  }
+
+  public removeMenuItemPermission(domainRoleId: number, permissionId: number): Promise<void> {
+    return HttpClient.Instance().client.delete(`webmenuitem/${domainRoleId}/permissions/${permissionId}`);
+  }
+}

package/src/lib/configuration/index.ts

@@ -0,0 +1,5 @@
+export * from './app-menu-item';
+export * from './client-ui';
+export * from './models';
+export * from './app-menu';
+export * from './app-menu-create-command';

package/src/lib/configuration/models/feature-list.ts

@@ -0,0 +1,8 @@
+import {Module} from "./module";
+import {Feature} from "./feature";
+
+export interface FeatureList {
+  modules: Module[];
+  features: Feature[];
+}
+