@edge-zuq/core 1.2.7

package/src/infra/axios-http-client-adapter.ts

@@ -0,0 +1,271 @@
+import { Platform } from 'react-native';
+
+import axios, { AxiosError } from 'axios';
+import type { AxiosResponse } from 'axios';
+
+import { HttpClient, type Storage } from '../data/protocols';
+import { HttpClientError } from '../data/errors';
+import type {
+  RecordRequest,
+  UserAuthentication,
+  UserLogout,
+} from '../domain/use-cases';
+import { addEventListener } from '@react-native-community/netinfo';
+
+export class AxiosHttpClientAdapter implements HttpClient {
+  private readonly client;
+  private readonly storage: Storage;
+  private readonly recorder: RecordRequest;
+  public readonly login?: UserAuthentication;
+  private isConnected: boolean | null = null;
+  public readonly logout?: UserLogout;
+  private hasConnection: boolean | null = null;
+  private isRefreshingAuth: Promise<any> | null = null;
+
+  constructor(url: string, params: AxiosHttpClientAdapter.Options) {
+    const { storage, recorder, login, logout } = params ?? {};
+    this.storage = storage;
+    this.recorder = recorder;
+    this.login = login;
+    this.logout = logout;
+    this.client = axios.create({
+      baseURL: url,
+      headers: {
+        'platform': Platform.OS,
+        'accept': 'application/json',
+        'Content-Type': 'application/json',
+      },
+    });
+    addEventListener((state) => {
+      this.hasConnection = Boolean(
+        state.isConnected && state.isInternetReachable
+      );
+    });
+  }
+
+  private throwIfNotConnectedOrExecuted(
+    method: HttpClient.Method,
+    url: string,
+    body?: any,
+    config?: HttpClient.Config
+  ) {
+    const isOffline = config?.offline?.id?.isOffline() ?? false;
+    if (this.hasConnection === false || isOffline) {
+      throw new HttpClientError({
+        method,
+        url,
+        body,
+        config,
+        response: {
+          statusCode: undefined,
+          data: 'NOT CONNECTED',
+          headers: {},
+        },
+      });
+    }
+  }
+
+  private needsLogin(res: AxiosResponse<any>) {
+    return (
+      res.status === 401 ||
+      (typeof res.data === 'string' &&
+        (res.data.includes('<!DOCTYPE') ||
+          res.data.includes('<html') ||
+          res.data.includes('<?xml')))
+    );
+  }
+
+  private refreshAuth = async () => {
+    if (!this.login) return false;
+    if (this.isRefreshingAuth) {
+      await this.isRefreshingAuth;
+      return true;
+    }
+    const [username, password] = this.storage.getItem<string[]>('__auth') ?? [];
+    if (username && password) {
+      this.isRefreshingAuth = this.login.authenticate({ username, password });
+      await this.isRefreshingAuth;
+      this.isRefreshingAuth = null;
+      return true;
+    }
+    return false;
+  };
+
+  private async refreshAuthIfNeeded(response: AxiosResponse<any>) {
+    const needsLogin = this.needsLogin(response);
+    if (needsLogin && this.login && this.logout) {
+      const succeded = await this.refreshAuth();
+      if (!succeded) {
+        const [username] = this.storage.getItem<string[]>('__auth') ?? [];
+        if (username) await this.logout.logout({ username });
+      }
+    }
+    return {
+      needsLogin,
+    };
+  }
+
+  private fromAxiosError<T>(e: AxiosError<any, T>): HttpClient.Error<T> {
+    const url = e.config?.url ?? 'no_url';
+    const method = e.config?.method as HttpClient.Method;
+    const error: HttpClient.Error<T> = {
+      url,
+      method,
+      body: e.config?.data,
+      response: {
+        headers: e.response?.headers,
+        data: e.response?.data,
+        statusCode: e.response?.status,
+      },
+      config: {
+        headers: e.config?.headers,
+        params: e.config?.params,
+      },
+    };
+    return new HttpClientError(error);
+  }
+
+  private async execute<T>(
+    handler: () => Promise<AxiosResponse<T>>
+  ): Promise<HttpClient.Response<T>> {
+    let response: AxiosResponse<T> | undefined;
+    let isRetry = false;
+    try {
+      response = await handler();
+      const { needsLogin } = await this.refreshAuthIfNeeded(response);
+      if (!needsLogin) {
+        return {
+          statusCode: response.status,
+          data: response.data,
+          headers: response.headers,
+        };
+      }
+      isRetry = true;
+      response = await handler();
+    } catch (e) {
+      if (!(e instanceof AxiosError)) throw e;
+      if (!e.response?.status) throw e;
+      const error = this.fromAxiosError<T>(e);
+      if (isRetry) throw error;
+      try {
+        if (response) await this.refreshAuthIfNeeded(response);
+        else if (e.response) await this.refreshAuthIfNeeded(e.response);
+        response = await handler();
+      } catch (e) {
+        if (!(e instanceof AxiosError)) throw e;
+        throw this.fromAxiosError<T>(e);
+      }
+    }
+    if (this.isConnected && this.needsLogin(response)) {
+      const [username] = this.storage.getItem<string[]>('__auth') ?? [];
+      if (username) await this.logout?.logout({ username });
+      throw new Error('Needs login');
+    }
+    return {
+      statusCode: response.status,
+      data: response.data,
+      headers: response.headers,
+    };
+  }
+
+  async get<T = any>(
+    url: string,
+    config?: HttpClient.Config
+  ): Promise<HttpClient.Response<T>> {
+    const response = await this.execute<T>(() => this.client.get(url, config));
+    this.recorder.record({
+      url,
+      data: response.data,
+      headers: config?.headers,
+      query: config?.params,
+    });
+    return response;
+  }
+
+  async delete(
+    url: string,
+    config?: HttpClient.Config
+  ): Promise<HttpClient.Response<undefined>> {
+    this.recorder.record({
+      url,
+      headers: config?.headers,
+      query: config?.params,
+    });
+    this.throwIfNotConnectedOrExecuted(
+      HttpClient.Method.delete,
+      url,
+      undefined,
+      config
+    );
+    return this.execute<undefined>(() => this.client.delete(url, config));
+  }
+
+  async post<T = any>(
+    url: string,
+    body: any,
+    config?: HttpClient.Config
+  ): Promise<HttpClient.Response<T>> {
+    this.recorder.record({
+      url,
+      body,
+      headers: config?.headers,
+      query: config?.params,
+    });
+    this.throwIfNotConnectedOrExecuted(
+      HttpClient.Method.post,
+      url,
+      body,
+      config
+    );
+    return this.execute<T>(() => this.client.post(url, body, config));
+  }
+
+  async patch<T = any>(
+    url: string,
+    body: any,
+    config?: HttpClient.Config
+  ): Promise<HttpClient.Response<T>> {
+    this.recorder.record({
+      url,
+      body,
+      headers: config?.headers,
+      query: config?.params,
+    });
+    this.throwIfNotConnectedOrExecuted(
+      HttpClient.Method.patch,
+      url,
+      body,
+      config
+    );
+    return this.execute<T>(() => this.client.patch(url, body, config));
+  }
+
+  async put<T = any>(
+    url: string,
+    body: any,
+    config?: HttpClient.Config
+  ): Promise<HttpClient.Response<T>> {
+    this.recorder.record({
+      url,
+      body,
+      headers: config?.headers,
+      query: config?.params,
+    });
+    this.throwIfNotConnectedOrExecuted(
+      HttpClient.Method.put,
+      url,
+      body,
+      config
+    );
+    return this.execute<T>(() => this.client.put(url, body, config));
+  }
+}
+
+export namespace AxiosHttpClientAdapter {
+  export type Options = {
+    storage: Storage;
+    recorder: RecordRequest;
+    login?: UserAuthentication;
+    logout?: UserLogout;
+  };
+}

package/src/infra/index.ts

@@ -0,0 +1,7 @@
+export * from './rnp-permission-manager-adapter';
+export * from './axios-http-client-adapter';
+export * from './mmkv-storage-adapter';
+export * from './offline-mutation-queue';
+export * from './rnbu-download-manager-adapter';
+export * from './storage-cookie-manager-adapter';
+export * from './isomorphic-id-manager';

package/src/infra/isomorphic-id-manager.ts

@@ -0,0 +1,107 @@
+import type { Storage } from '../data/protocols';
+
+export class IsomorphicIdManager {
+  private readonly STORAGE_KEY = '__isomorphic_id_manager';
+  private readonly idMap: Map<string, IsomorphicIdManager.IsomorphicId> =
+    new Map();
+
+  constructor(private readonly storage: Storage) {
+    const storedIdMap = this.storage.getItem<
+      Record<string, { offlineId: number; realId?: number }>
+    >(this.STORAGE_KEY);
+    if (!storedIdMap) return;
+    this.idMap = new Map<string, IsomorphicIdManager.IsomorphicId>(
+      Object.entries(storedIdMap).map(([key, value]) => [
+        key,
+        new IsomorphicIdManager.IsomorphicId(value.offlineId, value.realId),
+      ])
+    );
+  }
+
+  private _save() {
+    const currentIdMap = Object.fromEntries(this.idMap);
+    this.storage.setItem(this.STORAGE_KEY, currentIdMap);
+  }
+
+  public isOffline(id: number): boolean {
+    const saved = this.idMap.get(String(id));
+    if (!saved) return false;
+    return saved.isOffline();
+  }
+
+  public create(id: number): IsomorphicIdManager.IsomorphicId {
+    const current = this.idMap.get(String(id));
+    if (current) return current;
+    const isomorphicId = new IsomorphicIdManager.IsomorphicId(id);
+    this.set(id, isomorphicId);
+    return isomorphicId;
+  }
+
+  public get(id: number): IsomorphicIdManager.IsomorphicId {
+    const saved = this.idMap.get(String(id));
+    if (!saved) {
+      const isomorphicId = this.create(id);
+      this.update(id, id);
+      return isomorphicId;
+    }
+    return saved;
+  }
+
+  public set(id: number, isomorphicId: IsomorphicIdManager.IsomorphicId): void {
+    this.idMap.set(String(id), isomorphicId);
+    this._save();
+  }
+
+  public update(id: number, realId: number): void {
+    const current = this.idMap.get(String(id));
+    if (!current) return;
+    current.set(realId);
+    this.set(id, current);
+  }
+
+  public remove(id: number): void {
+    this.idMap.delete(String(id));
+    this._save();
+  }
+
+  public clear(): void {
+    this.idMap.clear();
+    this._save();
+  }
+}
+
+export namespace IsomorphicIdManager {
+  export class IsomorphicId {
+    private realId: number | undefined;
+    private offlineId: number;
+
+    constructor(id: number, realId?: number) {
+      this.offlineId = id;
+      this.realId = realId;
+    }
+
+    public isFromOffline() {
+      return this.realId !== this.offlineId;
+    }
+
+    public getOfflineId() {
+      return this.offlineId;
+    }
+
+    public getRealId() {
+      return this.realId;
+    }
+
+    public get() {
+      return this.realId ?? this.offlineId;
+    }
+
+    public set(id: number) {
+      this.realId = id;
+    }
+
+    public isOffline() {
+      return this.realId === undefined;
+    }
+  }
+}

package/src/infra/mmkv-storage-adapter.ts

@@ -0,0 +1,73 @@
+import { createMMKV } from 'react-native-mmkv';
+
+import type { Storage } from '../data/protocols';
+
+export class MMKVStorageAdapter implements Storage {
+  private readonly storage;
+
+  constructor({ id, encryptionKey }: MMKVStorageAdapter.Params) {
+    this.storage = createMMKV({
+      id,
+      encryptionKey,
+    });
+  }
+
+  public get(params?: Storage.GetParams) {
+    const { exclude = [] } = params ?? {};
+    const keys = this.storage.getAllKeys();
+    return keys.reduce(
+      (acc, key) => {
+        if (exclude.includes(key)) return acc;
+        return {
+          ...acc,
+          [key]: this.getItem(key),
+        };
+      },
+      {} as Record<string, any>
+    );
+  }
+
+  public getItem<T = any>(key: string): T | null {
+    const value = this.storage.getString(key);
+    try {
+      return value ? (JSON.parse(value) as T) : null;
+    } catch (e) {
+      console.info('[STORAGE]: error on JSON parse', e);
+      this.removeItem(key);
+      return null;
+    }
+  }
+
+  public removeItem(key: string): void {
+    this.storage.remove(key);
+  }
+
+  public setItem<T = any>(key: string, value: T): void {
+    if (value === undefined || value === null) {
+      console.info('[STORAGE]: setItem called with undefined/null');
+      this.removeItem(key);
+    } else {
+      this.storage.set(key, JSON.stringify(value));
+    }
+  }
+
+  public clear() {
+    this.storage.clearAll();
+  }
+
+  public reset(params?: Storage.ResetParams) {
+    const { exclude = [] } = params ?? {};
+    const keys = this.storage.getAllKeys();
+    for (const key of keys) {
+      if (exclude.includes(key)) return;
+      this.removeItem(key);
+    }
+  }
+}
+
+export namespace MMKVStorageAdapter {
+  export type Params = {
+    id: string;
+    encryptionKey?: string;
+  };
+}

package/src/infra/notifee-notification-manager-adapter.ts

@@ -0,0 +1,87 @@
+import type { NotificationManager } from '../data/protocols';
+import notifee, { AndroidImportance, TriggerType } from '@notifee/react-native';
+import { theme } from '../theme';
+import { Platform } from 'react-native';
+
+export namespace NotifeeNotificationManagerAdapter {
+  export type Options = {
+    channelId: string;
+    channelName: string;
+    icon?: string;
+  };
+}
+
+export class NotifeeNotificationManagerAdapter implements NotificationManager {
+  public notifications: NotificationManager.Message[] = [];
+
+  constructor(
+    private readonly options: NotifeeNotificationManagerAdapter.Options
+  ) {}
+
+  async display(message: NotificationManager.Message) {
+    const channelId = await notifee.createChannel({
+      id: this.options.channelId,
+      name: this.options.channelName,
+    });
+
+    await notifee.displayNotification({
+      title: message.title,
+      body: message.body,
+      android: {
+        smallIcon: this.options.icon ?? 'ic_small_icon',
+        channelId,
+      },
+    });
+
+    this.notifications = [...this.notifications, message];
+  }
+
+  async trigger(message: NotificationManager.Message) {
+    const channelId = await notifee.createChannel({
+      id: this.options.channelId,
+      name: this.options.channelName,
+    });
+    await notifee.createTriggerNotification(
+      {
+        title: message.title,
+        body: message.body,
+        android: {
+          channelId,
+          smallIcon: this.options.icon ?? 'ic_small_icon',
+        },
+      },
+      {
+        type: TriggerType.TIMESTAMP,
+        timestamp: message.date,
+      }
+    );
+  }
+
+  async foreground(options: NotificationManager.ForegroundOptions) {
+    if (Platform.OS !== 'android') return;
+
+    const channelId = await notifee.createChannel({
+      id: `${this.options.channelId}-foreground`,
+      name: `${this.options.channelName}-foreground`,
+      importance: AndroidImportance.MIN,
+    });
+
+    notifee.displayNotification({
+      title: options.title,
+      body: options.body,
+      android: {
+        smallIcon: this.options.icon ?? 'ic_small_icon',
+        channelId,
+        asForegroundService: true,
+        color: theme.color.brand.violet['500'],
+        colorized: true,
+        ongoing: true,
+        importance: AndroidImportance.MIN,
+        pressAction: {
+          id: 'foreground',
+          launchActivity: 'default',
+        },
+      },
+    });
+  }
+}