@edge-zuq/core 1.2.7

package/src/infra/offline-mutation-queue.ts

@@ -0,0 +1,280 @@
+import type { QueryClient, QueryKey } from '@tanstack/react-query';
+
+import type { HttpClient, Storage } from '../data/protocols';
+import { handleQuerySuccess } from '../presentation/domain/offline';
+import { IsomorphicIdManager } from './isomorphic-id-manager';
+
+export type OfflineActions = Record<string, Function>;
+
+export enum OfflineMutationStatus {
+  PENDING = 'pending',
+  EXECUTING = 'executing',
+  ERROR = 'error',
+  SUCCESS = 'success',
+}
+
+export type OfflineMutationData = {
+  url: string;
+  method: keyof HttpClient;
+  body: any;
+  params?: any;
+  headers?: any;
+};
+
+export type OfflineMutation = {
+  id: string;
+  type: keyof OfflineActions;
+  data: OfflineMutationData;
+  response: null | undefined | any;
+  error: null | undefined | any;
+  queryKeysToInvalidate: QueryKey[];
+  status: OfflineMutationStatus;
+  dependencies: (string | IsomorphicIdManager.IsomorphicId)[];
+  createdAt: Date;
+  context?: any;
+};
+
+export class OfflineMutationQueue {
+  private readonly STORAGE_KEY = '__offline_queue';
+  private queue: Map<string, OfflineMutation> = new Map();
+
+  constructor(
+    private readonly actions: OfflineActions,
+    private readonly storage: Storage,
+    private readonly queryClient: QueryClient,
+    private readonly isomorphicIdManager?: IsomorphicIdManager
+  ) {
+    const storedQueue = storage.getItem<Record<string, OfflineMutation>>(
+      this.STORAGE_KEY
+    );
+    if (storedQueue) {
+      this.queue = new Map<string, OfflineMutation>(
+        Object.entries(storedQueue)
+      );
+    }
+  }
+
+  private update() {
+    const currentQueue = Object.fromEntries(this.queue);
+    this.storage.setItem(this.STORAGE_KEY, currentQueue);
+  }
+
+  private remove(key: string) {
+    this.queue.delete(key);
+    this.update();
+  }
+
+  private areDependenciesExecuted(offlineMutation: OfflineMutation) {
+    return offlineMutation.dependencies.every((key) => {
+      let currentKey;
+      if (key instanceof IsomorphicIdManager.IsomorphicId) {
+        const isomorphicId = this.isomorphicIdManager?.get(key.getOfflineId());
+        if (!isomorphicId || !isomorphicId.isOffline()) return true;
+        currentKey = String(isomorphicId.getOfflineId());
+      } else {
+        currentKey = key;
+      }
+      const dependency = this.queue.get(currentKey);
+      if (!dependency) return true;
+      return dependency.status === OfflineMutationStatus.SUCCESS;
+    });
+  }
+
+  private updateStatus(key: string, status: OfflineMutationStatus) {
+    const offlineMutation = this.queue.get(key);
+    if (!offlineMutation) {
+      console.warn(
+        '[OFFLINE]: Invalid key detected. Update will be discarded.'
+      );
+      return;
+    }
+    offlineMutation.status = status;
+    this.queue.set(key, offlineMutation);
+    this.update();
+  }
+
+  private updateResponse(key: string, response: any) {
+    const offlineMutation = this.queue.get(key);
+    if (!offlineMutation) {
+      console.warn(
+        '[OFFLINE]: Invalid key detected. Update will be discarded.'
+      );
+      return;
+    }
+    offlineMutation.response = response;
+    offlineMutation.status = OfflineMutationStatus.SUCCESS;
+    this.queue.set(key, offlineMutation);
+    if (response.id) {
+      this.isomorphicIdManager?.update(Number(key), response.id);
+    }
+    this.update();
+  }
+
+  private updateError(key: string, error: any) {
+    const offlineMutation = this.queue.get(key);
+    if (!offlineMutation) {
+      console.warn(
+        '[OFFLINE]: Invalid key detected. Update will be discarded.'
+      );
+      return;
+    }
+    offlineMutation.error = error;
+    offlineMutation.status = OfflineMutationStatus.ERROR;
+    this.queue.set(key, offlineMutation);
+    this.update();
+  }
+
+  private async invalidateQueries(offlineMutation: OfflineMutation) {
+    const { queryKeysToInvalidate = [] } = offlineMutation;
+    for (const queryKey of queryKeysToInvalidate) {
+      this.queryClient.invalidateQueries({
+        queryKey,
+      });
+    }
+  }
+
+  private isExecuting(offlineMutation: OfflineMutation) {
+    return offlineMutation.status === OfflineMutationStatus.EXECUTING;
+  }
+
+  private async executeRequest(key: string, offlineMutation: OfflineMutation) {
+    this.updateStatus(key, OfflineMutationStatus.EXECUTING);
+    const dependencies = offlineMutation.dependencies.map((dependency) =>
+      dependency instanceof IsomorphicIdManager.IsomorphicId
+        ? this.queue.get(String(dependency.getOfflineId()))
+        : this.queue.get(dependency)
+    );
+    const action = this.actions[offlineMutation.type];
+    if (!action) {
+      console.warn(
+        `[OFFLINE]: No action registered for this offline mutation with type ${offlineMutation.type}. It will be ignored.`
+      );
+      return;
+    }
+    const response = await action(offlineMutation, dependencies);
+    this.updateResponse(key, response.data);
+  }
+
+  private async executeAllDependencies(offlineMutation: OfflineMutation) {
+    const { dependencies } = offlineMutation;
+    let allDependenciesExecutedSuccessfully = true;
+    for (const key of dependencies) {
+      let currentKey;
+      if (key instanceof IsomorphicIdManager.IsomorphicId) {
+        const isomorphicId = this.isomorphicIdManager?.get(key.getOfflineId());
+        if (!isomorphicId || !isomorphicId.isOffline()) continue;
+        currentKey = String(isomorphicId.getOfflineId());
+      } else {
+        currentKey = key;
+      }
+      const dependency = this.queue.get(currentKey);
+      if (!dependency || this.isAlreadyExecuted(dependency)) continue;
+      try {
+        if (!this.areDependenciesExecuted(dependency)) {
+          await this.executeAllDependencies(dependency);
+        }
+        await this.executeRequest(currentKey, dependency);
+        await this.invalidateQueries(dependency);
+      } catch (err) {
+        allDependenciesExecutedSuccessfully = false;
+        this.updateError(currentKey, err);
+      }
+    }
+    return allDependenciesExecutedSuccessfully;
+  }
+
+  private assertOfflineMutation(key: string, offlineMutation: OfflineMutation) {
+    const isValid = offlineMutation.dependencies.every((dependencyKey) => {
+      let dependency: OfflineMutation | undefined;
+      if (dependencyKey instanceof IsomorphicIdManager.IsomorphicId) {
+        const isomorphicId = this.isomorphicIdManager?.get(
+          dependencyKey.getOfflineId()
+        );
+        if (!isomorphicId) return false;
+        if (isomorphicId.isOffline()) {
+          dependency = this.queue.get(String(dependencyKey.getOfflineId()));
+        } else {
+          return true;
+        }
+      } else {
+        dependency = this.queue.get(dependencyKey);
+      }
+      if (dependency) {
+        const existsDependencyLoop = dependency.dependencies.some(
+          (innerKey) => innerKey === key
+        );
+        return !existsDependencyLoop;
+      } else {
+        return false;
+      }
+    });
+    if (!isValid) {
+      throw new Error(
+        '[OFFLINE]: A dependency loop or invalid dependency was detected. This offline mutation will be discarded.'
+      );
+    }
+  }
+
+  private isAlreadyExecuted(offlineMutation: OfflineMutation) {
+    if (!offlineMutation) return true;
+    return (
+      offlineMutation.status === OfflineMutationStatus.SUCCESS ||
+      offlineMutation.status === OfflineMutationStatus.ERROR
+    );
+  }
+
+  public size() {
+    return this.queue.size;
+  }
+
+  public list() {
+    return [...this.queue.values()];
+  }
+
+  public clear() {
+    [...this.queue.entries()].forEach(([key]) => {
+      this.remove(key);
+    });
+    this.isomorphicIdManager?.clear();
+  }
+
+  public push(key: string, offlineMutation: OfflineMutation) {
+    try {
+      this.assertOfflineMutation(key, offlineMutation);
+      console.info('[OFFLINE]: Pushing to offline queue!');
+      this.queue.set(key, offlineMutation);
+      this.update();
+    } catch (err) {
+      console.error(err);
+    }
+  }
+
+  public async execute() {
+    for (const [key, offlineMutation] of this.queue) {
+      if (
+        this.isAlreadyExecuted(offlineMutation) ||
+        this.isExecuting(offlineMutation)
+      ) {
+        continue;
+      }
+      const allDependenciesExecuted =
+        this.executeAllDependencies(offlineMutation);
+      if (!allDependenciesExecuted) continue;
+      try {
+        await this.executeRequest(key, offlineMutation);
+        await this.invalidateQueries(offlineMutation);
+        for (const queryKey of offlineMutation.queryKeysToInvalidate) {
+          handleQuerySuccess({
+            queryClient: this.queryClient,
+            queryKey,
+          });
+        }
+      } catch (err) {
+        if (err) this.updateError(key, err);
+        console.error(
+          `[OFFLINE]: error on mutation with type ${offlineMutation.type} and key: ${key}`
+        );
+      }
+    }
+  }
+}

package/src/infra/rnbu-download-manager-adapter.ts

@@ -0,0 +1,29 @@
+import type { DownloadManager, HttpClient } from '../data/protocols';
+import ReactNativeBlobUtil from 'react-native-blob-util';
+import { Buffer } from 'buffer';
+import { SaveFileError } from '../data/errors';
+import { Platform } from 'react-native';
+
+export class RNBUDownloadManagerAdapter implements DownloadManager {
+  constructor(private readonly httpClient: HttpClient) {}
+  async save(params: DownloadManager.SaveParams): DownloadManager.SaveResult {
+    const defaultDir =
+      Platform.OS === 'android'
+        ? ReactNativeBlobUtil.fs.dirs.LegacyDownloadDir
+        : ReactNativeBlobUtil.fs.dirs.DocumentDir;
+
+    const { url, fileName, directory = defaultDir } = params;
+    const response = await this.httpClient.get(url, {
+      responseType: 'arraybuffer',
+    });
+
+    try {
+      const base64Data = Buffer.from(response.data).toString('base64');
+      const filePath = `${directory}/${fileName}`;
+      await ReactNativeBlobUtil.fs.writeFile(filePath, base64Data, 'base64');
+      return filePath;
+    } catch (err) {
+      throw new SaveFileError('Falha ao salvar o arquivo.');
+    }
+  }
+}

package/src/infra/rnp-permission-manager-adapter.ts

@@ -0,0 +1,147 @@
+import type { PermissionManager } from '../data/protocols';
+import RNPermissions, { PERMISSIONS } from 'react-native-permissions';
+import { Platform } from 'react-native';
+import { UnsupportedPlatform } from '../data/errors';
+
+export class RNPPermissionManagerAdapter implements PermissionManager {
+  private readonly os = Platform.OS;
+  private readonly map = {
+    NOTIFICATIONS: {
+      android: null,
+      ios: null,
+    },
+    CAMERA: {
+      android: PERMISSIONS.ANDROID.CAMERA,
+      ios: PERMISSIONS.IOS.CAMERA,
+    },
+    COARSE_LOCATION: {
+      android: PERMISSIONS.ANDROID.ACCESS_COARSE_LOCATION,
+      ios: PERMISSIONS.IOS.LOCATION_WHEN_IN_USE,
+    },
+    FINE_LOCATION: {
+      android: PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION,
+      ios: PERMISSIONS.IOS.LOCATION_WHEN_IN_USE,
+    },
+    BACKGROUND_LOCATION: {
+      android: PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION,
+      ios: PERMISSIONS.IOS.LOCATION_ALWAYS,
+    },
+    WRITE_EXTERNAL_STORAGE: {
+      android: PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE,
+      ios: null,
+    },
+    DATA_COLLECTION: {
+      android: null,
+      ios: PERMISSIONS.IOS.APP_TRACKING_TRANSPARENCY,
+    },
+  };
+
+  private checkOS() {
+    if (!['android', 'ios'].includes(this.os)) throw new UnsupportedPlatform();
+  }
+
+  private getCurrentOSPermission(permission: PermissionManager.Permission) {
+    return this.map[permission][this.os as 'android' | 'ios'];
+  }
+
+  async get(
+    permission: PermissionManager.Permission
+  ): Promise<PermissionManager.Result> {
+    this.checkOS();
+    if (permission === 'NOTIFICATIONS') return this.hasNotifications();
+    const currentOSPermission = this.getCurrentOSPermission(permission);
+    if (!currentOSPermission) return 'unavailable';
+    return RNPermissions.check(currentOSPermission);
+  }
+
+  async getAll(
+    permissions: PermissionManager.Permission[]
+  ): Promise<PermissionManager.Result[]> {
+    return await Promise.all(
+      permissions.map((permission) => this.get(permission))
+    );
+  }
+
+  async checkNoop(permission: string) {
+    if (
+      permission === PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE &&
+      this.os === 'android' &&
+      Number(Platform.Version) >= 33
+    )
+      return 'granted';
+    return;
+  }
+
+  async request(
+    permission: PermissionManager.Permission,
+    options: PermissionManager.Options
+  ): Promise<PermissionManager.Result> {
+    this.checkOS();
+    if (permission === 'NOTIFICATIONS')
+      return this.requestNotifications(options);
+    const currentOSPermission = this.getCurrentOSPermission(permission);
+    if (!currentOSPermission) return 'unavailable';
+    const isNoop = await this.checkNoop(currentOSPermission);
+    if (isNoop) return isNoop;
+    const { title, message, allow = 'Permitir', deny = 'Recusar' } = options;
+    return RNPermissions.request(currentOSPermission, {
+      title,
+      message,
+      buttonPositive: allow,
+      buttonNegative: deny,
+    });
+  }
+
+  async requestAll(
+    data: Array<{
+      permission: PermissionManager.Permission;
+      options: PermissionManager.Options;
+    }>
+  ): Promise<PermissionManager.Result[]> {
+    return await Promise.all(
+      data.map((item) => this.request(item.permission, item.options))
+    );
+  }
+
+  async hasNotifications() {
+    const result = await RNPermissions.checkNotifications();
+    return result.status;
+  }
+
+  async requestNotifications(options: PermissionManager.Options) {
+    this.checkOS();
+    const { title, message, allow = 'Permitir', deny = 'Recusar' } = options;
+    const { status } = await RNPermissions.requestNotifications(
+      ['alert', 'sound'],
+      {
+        title,
+        message,
+        buttonPositive: allow,
+        buttonNegative: deny,
+      }
+    );
+    return status;
+  }
+
+  async has(permission: PermissionManager.Permission): Promise<boolean> {
+    this.checkOS();
+    const currentOSPermission = this.getCurrentOSPermission(permission);
+    if (!currentOSPermission) return true;
+    const isNoop = await this.checkNoop(currentOSPermission);
+    if (isNoop) return true;
+    const currentPermissionStatus =
+      await RNPermissions.check(currentOSPermission);
+    return ['granted', 'limited', 'unavailable'].includes(
+      currentPermissionStatus
+    );
+  }
+
+  async hasEvery(
+    permissions: PermissionManager.Permission[]
+  ): Promise<boolean> {
+    const result = await Promise.all(
+      permissions.map(async (permission) => this.has(permission))
+    );
+    return result.every((item) => Boolean(item));
+  }
+}

package/src/infra/storage-cookie-manager-adapter.ts

@@ -0,0 +1,29 @@
+import type { CookieManager, Storage } from '../data/protocols';
+
+export class StorageCookieManagerAdapter implements CookieManager {
+  private cookies: Record<string, string | undefined> = {};
+
+  constructor(
+    private readonly storage: Storage,
+    private readonly cookiesKey: string
+  ) {
+    this.cookies = this.storage.getItem(this.cookiesKey) ?? {};
+  }
+
+  public get(key: string) {
+    return this.cookies[key];
+  }
+
+  public set(key: string, value: string | undefined) {
+    this.cookies[key] = value;
+    return this.storage.setItem(this.cookiesKey, this.cookies);
+  }
+
+  public remove(key: string) {
+    return this.set(key, undefined);
+  }
+
+  public clear() {
+    return this.storage.removeItem(this.cookiesKey);
+  }
+}

package/src/main/components/index.ts

@@ -0,0 +1,4 @@
+export * from './request-permissions';
+export * from '../../presentation/components/atoms';
+export * from '../../presentation/components/molecules';
+export * from '../../presentation/components/organisms';

package/src/main/components/request-permissions.tsx

@@ -0,0 +1,17 @@
+import React from 'react';
+
+import { RequestPermissions as BaseRequestPermissions } from '../../presentation/components';
+import { makePermissionManager } from '../factories/infra';
+
+type Props = Omit<
+  React.ComponentProps<typeof BaseRequestPermissions>,
+  'permissionManager'
+>;
+
+export const RequestPermissions = (props: Props) => {
+  const permissionManager = React.useMemo(() => makePermissionManager(), []);
+
+  return (
+    <BaseRequestPermissions permissionManager={permissionManager} {...props} />
+  );
+};

package/src/main/factories/infra/download-manager-factory.ts

@@ -0,0 +1,6 @@
+import type { DownloadManager, HttpClient } from '../../../data/protocols';
+import { RNBUDownloadManagerAdapter } from '../../../infra';
+
+export const makeDownloadManager = (client: HttpClient): DownloadManager => {
+  return new RNBUDownloadManagerAdapter(client);
+};

package/src/main/factories/infra/http-client-factory.ts

@@ -0,0 +1,9 @@
+import type { HttpClient } from '../../../data/protocols';
+import { AxiosHttpClientAdapter } from '../../../infra';
+
+export const makeHttpClient = (
+  url: string,
+  options: AxiosHttpClientAdapter.Options
+): HttpClient => {
+  return new AxiosHttpClientAdapter(url, options);
+};

package/src/main/factories/infra/index.ts

@@ -0,0 +1,7 @@
+export * from './permission-manager-factory';
+export * from './notification-manager-factory';
+export * from './storage-factory';
+export * from './http-client-factory';
+export * from './offline-mutation-queue-factory';
+export * from './download-manager-factory';
+export * from './isomorphic-id-manager-factory';

package/src/main/factories/infra/isomorphic-id-manager-factory.ts

@@ -0,0 +1,6 @@
+import { IsomorphicIdManager } from '../../../infra';
+import type { Storage } from '../../../data/protocols';
+
+export const makeIsomorphicIdManager = (storage: Storage) => {
+  return new IsomorphicIdManager(storage);
+};

package/src/main/factories/infra/notification-manager-factory.ts

@@ -0,0 +1,8 @@
+import type { NotificationManager } from '../../../data/protocols';
+import { NotifeeNotificationManagerAdapter } from '../../../infra/notifee-notification-manager-adapter';
+
+export const makeNotificationManager = (
+  options: NotifeeNotificationManagerAdapter.Options
+): NotificationManager => {
+  return new NotifeeNotificationManagerAdapter(options);
+};

package/src/main/factories/infra/offline-mutation-queue-factory.ts

@@ -0,0 +1,22 @@
+import type { QueryClient } from '@tanstack/react-query';
+import type { Storage } from '../../../data/protocols';
+
+import {
+  IsomorphicIdManager,
+  OfflineMutationQueue,
+  type OfflineActions,
+} from '../../../infra';
+
+export const makeOfflineMutationQueue = (
+  actions: OfflineActions,
+  storage: Storage,
+  queryClient: QueryClient,
+  isomorphicIdManager?: IsomorphicIdManager
+) => {
+  return new OfflineMutationQueue(
+    actions,
+    storage,
+    queryClient,
+    isomorphicIdManager
+  );
+};

package/src/main/factories/infra/permission-manager-factory.ts

@@ -0,0 +1,6 @@
+import type { PermissionManager } from '../../../data/protocols';
+import { RNPPermissionManagerAdapter } from '../../../infra';
+
+export const makePermissionManager = (): PermissionManager => {
+  return new RNPPermissionManagerAdapter();
+};

package/src/main/factories/infra/storage-factory.ts

@@ -0,0 +1,11 @@
+import type { Storage } from '../../../data/protocols';
+import { MMKVStorageAdapter } from '../../../infra';
+
+export const makeStorage = (
+  params: MMKVStorageAdapter.Params = {
+    id: 'zuq',
+    encryptionKey: 'zuq-encryption-key',
+  }
+): Storage => {
+  return new MMKVStorageAdapter(params);
+};

package/src/main/factories/use-cases/index.ts

@@ -0,0 +1,3 @@
+export * from './remote-get-image-list-factory';
+export * from './remote-get-comment-list-factory';
+export * from './remote-send-diagnostics-factory';

package/src/main/factories/use-cases/remote-get-comment-list-factory.ts

@@ -0,0 +1,6 @@
+import type { HttpClient } from '../../../data/protocols';
+import { RemoteGetCommentList } from '../../../data/use-cases';
+
+export const makeGetCommentList = (url: string, httpClient: HttpClient) => {
+  return new RemoteGetCommentList(url, httpClient);
+};

package/src/main/factories/use-cases/remote-get-image-list-factory.ts

@@ -0,0 +1,6 @@
+import type { HttpClient } from '../../../data/protocols';
+import { RemoteGetImageList } from '../../../data/use-cases';
+
+export const makeGetImageList = (url: string, httpClient: HttpClient) => {
+  return new RemoteGetImageList(url, httpClient);
+};

package/src/main/factories/use-cases/remote-send-diagnostics-factory.ts

@@ -0,0 +1,10 @@
+import type { HttpClient, Storage } from '../../../data/protocols';
+import { RemoteSendDiagnostics } from '../../../data/use-cases';
+
+export const makeRemoteSendDiagnostics = (
+  url: string,
+  httpClient: HttpClient,
+  storage: Storage
+) => {
+  return new RemoteSendDiagnostics(url, httpClient, storage);
+};

package/src/presentation/components/atoms/UIBackdrop.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+import { Pressable, StyleSheet } from 'react-native';
+import Animated, { FadeIn, FadeOut } from 'react-native-reanimated';
+
+type Props = React.ComponentProps<typeof Pressable> & {
+  visible: boolean;
+  onPress?: () => void;
+  animationDuration?: number;
+};
+
+const AnimatedPressable = Animated.createAnimatedComponent(Pressable);
+
+export const UIBackdrop = React.memo(
+  ({ onPress, style, animationDuration = 300, visible, ...props }: Props) => {
+    if (!visible) return null;
+
+    return (
+      <AnimatedPressable
+        onPress={onPress}
+        entering={FadeIn.duration(animationDuration)}
+        exiting={FadeOut.duration(animationDuration)}
+        style={[styles.backdrop, style]}
+        {...props}
+      />
+    );
+  }
+);
+
+const styles = StyleSheet.create({
+  backdrop: {
+    ...StyleSheet.absoluteFillObject,
+    zIndex: 10,
+    backgroundColor: 'rgba(0,0,0,0.40)',
+  },
+});