nico-tools 1.0.0 → 1.1.0

package/templates/react-native/expo-clean-architecture/src/core/helpers/rest-client.ts

@@ -0,0 +1,144 @@
+import {
+  RestClientOptions,
+  GetRequestConfig,
+  PostRequestConfig,
+  PutRequestConfig,
+  DeleteRequestConfig,
+  RequestConfig,
+} from "@/core/helpers/@types";
+
+export abstract class RestClient {
+  private readonly baseUrl: string;
+  private readonly defaultHeaders: Record<string, string>;
+
+  constructor(options: RestClientOptions) {
+    this.baseUrl = options.baseUrl || "";
+    this.defaultHeaders = options.headers || {};
+  }
+
+  /**
+   * Perform a GET request to the server
+   * @param options - The options for the request
+   * @returns The resource
+   */
+  async get<T>(options: GetRequestConfig): Promise<T> {
+    try {
+      const response = await fetch(
+        this.getFullUrl(options.path, options.queryParameters),
+        {
+          ...options,
+          headers: this.getHeaders(options),
+        }
+      );
+
+      return this.handleResponse<T>(response);
+    } catch (error) {
+      return this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * Perform a POST request to the server
+   * @param config - The config for the request
+   * @returns The resource
+   */
+  async post<T>(config: PostRequestConfig): Promise<T> {
+    try {
+      const response = await fetch(this.getFullUrl(config.path), {
+        ...config,
+        method: "POST",
+        body: JSON.stringify(config.body),
+        headers: this.getHeaders(config),
+      });
+      return this.handleResponse<T>(response);
+    } catch (error) {
+      return this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * Perform a PUT request to the server
+   * @param config - The config for the request
+   * @returns The resource
+   */
+  async put<T>(config: PutRequestConfig): Promise<T> {
+    try {
+      const response = await fetch(this.getFullUrl(config.path), {
+        ...config,
+        method: "PUT",
+        body: JSON.stringify(config.body),
+        headers: this.getHeaders(config),
+      });
+      return this.handleResponse<T>(response);
+    } catch (error) {
+      return this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * Perform a DELETE request to the server
+   * @param config - The config for the request
+   * @returns The resource
+   */
+  async delete<T>(config: DeleteRequestConfig): Promise<T> {
+    try {
+      const response = await fetch(this.getFullUrl(config.path), {
+        ...config,
+        method: "DELETE",
+        headers: this.getHeaders(config),
+      });
+      return this.handleResponse<T>(response);
+    } catch (error) {
+      return this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * Get the full URL for a request
+   * @param path - The path of the resource
+   * @param queryParameters - The query parameters for the request - _Optional_
+   * @returns The full URL
+   */
+  private getFullUrl(
+    path: string,
+    queryParameters?: Record<string, string>
+  ): string {
+    const queryString = queryParameters
+      ? `?${new URLSearchParams(queryParameters).toString()}`
+      : "";
+    return `${this.baseUrl}${path}${queryString}`;
+  }
+
+  /**
+   * Concatenate the default headers with the request headers
+   * @param config - The config for the request
+   * @returns The headers
+   */
+  private getHeaders(config?: RequestConfig): Record<string, string> {
+    return {
+      ...this.defaultHeaders,
+      ...config?.options?.headers?.toString,
+    };
+  }
+
+  /**
+   * Handle the response from the server
+   * @param response - The response from the server
+   * @returns The resource as a JSON object, or throws an error if the response is not ok
+   */
+  private handleResponse<T>(response: Response): Promise<T> {
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return response.json();
+  }
+
+  /**
+   * Handle the error from the server
+   * @param error - The error from the server
+   * @returns The error
+   */
+  private handleError(error: Error): Promise<never> {
+    throw error;
+  }
+}

package/templates/react-native/expo-clean-architecture/src/core/helpers/result.ts

@@ -0,0 +1,37 @@
+export abstract class Result<T> {
+  data: T | null;
+  error: Error | null;
+
+  constructor(data: T, error: Error | null) {
+    this.data = data;
+    this.error = error;
+  }
+
+  get isSuccess(): boolean {
+    return this instanceof Success;
+  }
+
+  get isFailure(): boolean {
+    return this instanceof Failure;
+  }
+
+  static success<T>(data: T): Success<T> {
+    return new Success(data);
+  }
+
+  static failure(error: any): Failure {
+    return new Failure(error);
+  }
+}
+
+export class Success<T> extends Result<T> {
+  constructor(data: T) {
+    super(data, null);
+  }
+}
+
+export class Failure extends Result<null> {
+  constructor(error: Error) {
+    super(null, error);
+  }
+}

package/templates/react-native/expo-clean-architecture/src/core/helpers/usecase.ts

@@ -0,0 +1,5 @@
+import { Result } from "./result";
+
+export abstract class Usecase<Input, Output> {
+  abstract execute(input?: Input): Promise<Result<Output>>;
+}

package/templates/react-native/expo-clean-architecture/src/core/hooks/use-network.ts

@@ -0,0 +1,18 @@
+import { useEffect, useState } from "react";
+import container from "@/core/di/injection-container";
+import { NetworkService } from "@/core/services/network-service";
+
+export function useNetwork(): { isOnline: boolean } {
+  const networkService = container.get<NetworkService>(NetworkService);
+  const [isOnline, setIsOnline] = useState<boolean>(false);
+
+  useEffect(() => {
+    const unsubscribe = networkService.subscribe(setIsOnline);
+
+    return () => {
+      unsubscribe();
+    };
+  }, [networkService]);
+
+  return { isOnline };
+}

package/templates/react-native/expo-clean-architecture/src/core/i18n/@types/i18next.d.ts

@@ -0,0 +1,11 @@
+import "i18next";
+import fr from "@/core/i18n/translations/fr.json";
+
+declare module "i18next" {
+  interface CustomTypeOptions {
+    defaultNS: "fr";
+    resources: {
+      fr: typeof fr;
+    };
+  }
+}

package/templates/react-native/expo-clean-architecture/src/core/i18n/index.ts

@@ -0,0 +1,19 @@
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+import fr from "@/core/i18n/translations/fr.json";
+
+const resources = {
+  fr: {
+    translation: fr,
+  },
+};
+
+i18n.use(initReactI18next).init({
+  resources,
+  lng: "fr",
+  react: {
+    useSuspense: true,
+  },
+});
+
+export default i18n;

package/templates/react-native/expo-clean-architecture/src/core/i18n/translations/fr.json

@@ -0,0 +1,12 @@
+{
+  "common": {
+    "helloWorld": "Bonjour le monde"
+  },
+  "auth": {
+    "login": "Connexion",
+    "logout": "Déconnexion"
+  },
+  "home": {
+    "title": "Accueil"
+  }
+}

package/templates/react-native/expo-clean-architecture/src/core/services/local-storage-service-impl.ts

@@ -0,0 +1,29 @@
+import { injectable } from "inversify";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+import { LocalStorageService } from "@/core/services/local-storage-service";
+
+@injectable()
+export class LocalStorageServiceImpl extends LocalStorageService {
+  async getItem(key: string, defaultValue: string): Promise<string> {
+    const value = await AsyncStorage.getItem(key);
+
+    if (value === null) {
+      return defaultValue;
+    }
+
+    return value;
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    await AsyncStorage.setItem(key, value);
+  }
+
+  async removeItem(key: string): Promise<void> {
+    await AsyncStorage.removeItem(key);
+  }
+
+  async clear(): Promise<void> {
+    await AsyncStorage.clear();
+  }
+}

package/templates/react-native/expo-clean-architecture/src/core/services/local-storage-service.ts

@@ -0,0 +1,26 @@
+export abstract class LocalStorageService {
+  /**
+   * Get an item from the local storage
+   * @param key The key of the item to get
+   * @returns The item or null if it doesn't exist
+   */
+  abstract getItem(key: string, defaultValue: string): Promise<string>;
+
+  /**
+   * Set an item in the local storage
+   * @param key The key of the item to set
+   * @param value The value of the item to set
+   */
+  abstract setItem(key: string, value: string): Promise<void>;
+
+  /**
+   * Remove an item from the local storage
+   * @param key The key of the item to remove
+   */
+  abstract removeItem(key: string): Promise<void>;
+
+  /**
+   * Clear the local storage
+   */
+  abstract clear(): Promise<void>;
+}

package/templates/react-native/expo-clean-architecture/src/core/services/monitoring-service-impl.ts

@@ -0,0 +1,15 @@
+import { injectable } from "inversify";
+import {
+  recordError,
+  getCrashlytics,
+} from "@react-native-firebase/crashlytics";
+
+import { MonitoringService } from "@/core/services/monitoring-service";
+
+@injectable()
+export class MonitoringServiceImpl implements MonitoringService {
+  report(error: Error): void {
+    const crashlytics = getCrashlytics();
+    recordError(crashlytics, error);
+  }
+}

package/templates/react-native/expo-clean-architecture/src/core/services/monitoring-service.ts

@@ -0,0 +1,13 @@
+import { injectable } from "inversify";
+import {
+  recordError,
+  getCrashlytics,
+} from "@react-native-firebase/crashlytics";
+
+export abstract class MonitoringService {
+  /**
+   * Report an error to the monitoring service
+   * @param error - The error to report
+   */
+  abstract report(error: Error): void;
+}

package/templates/react-native/expo-clean-architecture/src/core/services/network-service-impl.ts

@@ -0,0 +1,40 @@
+import { injectable } from "inversify";
+import {
+  getNetworkStateAsync,
+  addNetworkStateListener,
+  NetworkState,
+} from "expo-network";
+import { NetworkService } from "@/core/services/network-service";
+import { NetworkStateChangeCallback } from "@/core/services/network-service";
+
+@injectable()
+export class NetworkServiceImpl implements NetworkService {
+  private listeners: Set<NetworkStateChangeCallback> = new Set();
+
+  constructor() {
+    // Initialize the listener when the service is created
+    addNetworkStateListener(this.handleNetworkStateChange);
+  }
+
+  private handleNetworkStateChange = (state: NetworkState) => {
+    const isOnline = state.isInternetReachable ?? false;
+    this.listeners.forEach((callback) => callback(isOnline));
+  };
+
+  async isOnline(): Promise<boolean> {
+    const networkState = await getNetworkStateAsync();
+    return networkState.isInternetReachable ?? false;
+  }
+
+  subscribe(callback: NetworkStateChangeCallback): () => void {
+    this.listeners.add(callback);
+
+    // Initial state check
+    this.isOnline().then((isOnline) => callback(isOnline));
+
+    // Return unsubscribe function
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+}

package/templates/react-native/expo-clean-architecture/src/core/services/network-service.ts

@@ -0,0 +1,16 @@
+export type NetworkStateChangeCallback = (isOnline: boolean) => void;
+
+export abstract class NetworkService {
+  /**
+   * Check if the device has an internet connection
+   * @returns true if the device has an internet connection, false otherwise
+   */
+  abstract isOnline(): Promise<boolean>;
+
+  /**
+   * Subscribe to the network state change
+   * @param callback - The function to be called when the network state changes
+   * @returns A function to unsubscribe from the network state change
+   */
+  abstract subscribe(callback: NetworkStateChangeCallback): () => void;
+}

package/templates/react-native/expo-clean-architecture/src/features/auth/@types/session-state.ts

@@ -0,0 +1,38 @@
+import { SessionStatus } from "@/features/auth/@types/session-status-enum";
+
+/**
+ * Represents the state of a user session and associated actions.
+ */
+export interface SessionState {
+  /**
+   * The current status of the session.
+   */
+  status: SessionStatus;
+
+  /**
+   * Logs in the user with the provided parameters.
+   * @param {LoginParamsEntity} params - The parameters required to log in the user.
+   */
+  login: () => Promise<void>;
+
+  /**
+   * Logs out the current user.
+   */
+  logout: () => void;
+
+  /**
+   * Attempts to silently log in the user without their intervention.
+   */
+  silentLogin: () => Promise<void>;
+
+  /**
+   * Checks if the user is currently authenticated.
+   * @returns {boolean} `true` if the user is authenticated, otherwise `false`.
+   */
+  isAuthenticated: () => boolean;
+
+  /**
+   * Indicates whether the session state has been initialized.
+   */
+  isInitialized: boolean;
+}

package/templates/react-native/expo-clean-architecture/src/features/auth/@types/session-status-enum.ts

@@ -0,0 +1,16 @@
+export enum SessionStatus {
+  /**
+   * The user is currently being authenticated or logged out.
+   */
+  LOADING,
+
+  /**
+   * The user is authenticated.
+   */
+  AUTHENTICATED,
+
+  /**
+   * The user is not authenticated.
+   */
+  UNAUTHENTICATED,
+}

package/templates/react-native/expo-clean-architecture/src/features/auth/presentation/hooks/use-session.ts

@@ -0,0 +1,18 @@
+import { create } from "zustand";
+import { SessionStatus } from "@/features/auth/@types/session-status-enum";
+import { SessionState } from "@/features/auth/@types/session-state";
+
+export const useSession = create<SessionState>((set, get) => ({
+  status: SessionStatus.UNAUTHENTICATED,
+  login: async () => {
+    set({ status: SessionStatus.AUTHENTICATED });
+  },
+  logout: async () => {
+    set({ status: SessionStatus.UNAUTHENTICATED });
+  },
+  silentLogin: async () => {
+    set({ status: SessionStatus.AUTHENTICATED });
+  },
+  isAuthenticated: () => get().status === SessionStatus.AUTHENTICATED,
+  isInitialized: false,
+}));

package/templates/react-native/expo-clean-architecture/src/features/favorites/data/datasources/favorites-datasource-impl.ts

@@ -0,0 +1,25 @@
+import { injectable, inject } from "inversify";
+
+import { LocalStorageService } from "@/core/services/local-storage-service";
+import { STORAGE_KEYS } from "@/core/constants/storage-keys";
+import { FavoritesDatasource } from "@/features/favorites/data/datasources/favorites-datasource";
+
+@injectable()
+export class FavoritesDatasourceImpl implements FavoritesDatasource {
+  constructor(
+    @inject(LocalStorageService)
+    private readonly localStorageService: LocalStorageService
+  ) {}
+
+  async getFavorites(): Promise<string> {
+    return await this.localStorageService.getItem(STORAGE_KEYS.FAVORITES, "[]");
+  }
+
+  async setFavorites(favorites: string): Promise<void> {
+    await this.localStorageService.setItem(STORAGE_KEYS.FAVORITES, favorites);
+  }
+
+  async clearFavorites(): Promise<void> {
+    await this.localStorageService.removeItem(STORAGE_KEYS.FAVORITES);
+  }
+}

package/templates/react-native/expo-clean-architecture/src/features/favorites/data/datasources/favorites-datasource.ts

@@ -0,0 +1,5 @@
+export abstract class FavoritesDatasource {
+  abstract setFavorites(favorites: string): Promise<void>;
+  abstract getFavorites(): Promise<string>;
+  abstract clearFavorites(): Promise<void>;
+}

package/templates/react-native/expo-clean-architecture/src/features/favorites/data/repositories/favorites-repository-impl.ts

@@ -0,0 +1,46 @@
+import { inject, injectable } from "inversify";
+import { FavoritesRepository } from "@/features/favorites/domain/repositories/favorites-repository";
+import { MovieEntity } from "@/features/movies/domain/entities/movie-entity";
+import { FavoritesDatasource } from "@/features/favorites/data/datasources/favorites-datasource";
+
+@injectable()
+export class FavoritesRepositoryImpl implements FavoritesRepository {
+  constructor(
+    @inject(FavoritesDatasource)
+    private readonly favoritesDatasource: FavoritesDatasource
+  ) {}
+
+  async addFavorite(movie: MovieEntity): Promise<void> {
+    const currentFavorites = await this.favoritesDatasource.getFavorites();
+
+    const newFavorites = [...JSON.parse(currentFavorites), movie];
+
+    await this.favoritesDatasource.setFavorites(JSON.stringify(newFavorites));
+  }
+
+  async removeFavorite(movieId: string): Promise<void> {
+    const currentFavorites = await this.favoritesDatasource.getFavorites();
+
+    const favorites = JSON.parse(currentFavorites);
+
+    const newFavorites = favorites.filter((movie: MovieEntity) => {
+      const parsedMovie = { ...movie };
+
+      return parsedMovie.id !== movieId;
+    });
+
+    await this.favoritesDatasource.setFavorites(JSON.stringify(newFavorites));
+  }
+
+  async getFavorites(): Promise<MovieEntity[]> {
+    const currentFavorites = await this.favoritesDatasource.getFavorites();
+
+    const favorites = JSON.parse(currentFavorites);
+
+    return favorites;
+  }
+
+  async clearFavorites(): Promise<void> {
+    await this.favoritesDatasource.clearFavorites();
+  }
+}

package/templates/react-native/expo-clean-architecture/src/features/favorites/domain/repositories/favorites-repository.ts

@@ -0,0 +1,8 @@
+import { MovieEntity } from "@/features/movies/domain/entities/movie-entity";
+
+export abstract class FavoritesRepository {
+  abstract getFavorites(): Promise<MovieEntity[]>;
+  abstract addFavorite(movie: MovieEntity): Promise<void>;
+  abstract removeFavorite(movieId: string): Promise<void>;
+  abstract clearFavorites(): Promise<void>;
+}

package/templates/react-native/expo-clean-architecture/src/features/favorites/domain/usecases/add-to-favorites-usecase.ts

@@ -0,0 +1,23 @@
+import { inject, injectable } from "inversify";
+
+import { Usecase } from "@/core/helpers/usecase";
+import { Result } from "@/core/helpers/result";
+import { FavoritesRepository } from "@/features/favorites/domain/repositories/favorites-repository";
+import { MovieEntity } from "@/features/movies/domain/entities/movie-entity";
+@injectable()
+export class AddToFavoritesUsecase implements Usecase<MovieEntity, void> {
+  constructor(
+    @inject(FavoritesRepository)
+    private readonly favoritesRepository: FavoritesRepository
+  ) {}
+
+  async execute(movie: MovieEntity): Promise<Result<void>> {
+    try {
+      await this.favoritesRepository.addFavorite(movie);
+
+      return Result.success(null);
+    } catch (error) {
+      return Result.failure(error);
+    }
+  }
+}

package/templates/react-native/expo-clean-architecture/src/features/favorites/domain/usecases/clear-favorites-usecase.ts

@@ -0,0 +1,23 @@
+import { inject, injectable } from "inversify";
+
+import { Usecase } from "@/core/helpers/usecase";
+import { Result } from "@/core/helpers/result";
+import { FavoritesRepository } from "@/features/favorites/domain/repositories/favorites-repository";
+
+@injectable()
+export class ClearFavoritesUsecase implements Usecase<void, void> {
+  constructor(
+    @inject(FavoritesRepository)
+    private readonly favoritesRepository: FavoritesRepository
+  ) {}
+
+  async execute(): Promise<Result<void>> {
+    try {
+      await this.favoritesRepository.clearFavorites();
+
+      return Result.success(null);
+    } catch (error) {
+      return Result.failure(error);
+    }
+  }
+}

package/templates/react-native/expo-clean-architecture/src/features/favorites/domain/usecases/get-favorites-usecase.ts

@@ -0,0 +1,24 @@
+import { inject, injectable } from "inversify";
+
+import { Result } from "@/core/helpers/result";
+import { Usecase } from "@/core/helpers/usecase";
+import { FavoritesRepository } from "@/features/favorites/domain/repositories/favorites-repository";
+import { MovieEntity } from "@/features/movies/domain/entities/movie-entity";
+
+@injectable()
+export class GetFavoritesUsecase implements Usecase<void, MovieEntity[]> {
+  constructor(
+    @inject(FavoritesRepository)
+    private readonly favoritesRepository: FavoritesRepository
+  ) {}
+
+  async execute(): Promise<Result<MovieEntity[]>> {
+    try {
+      const favorites = await this.favoritesRepository.getFavorites();
+
+      return Result.success(favorites);
+    } catch (error) {
+      return Result.failure(error);
+    }
+  }
+}

package/templates/react-native/expo-clean-architecture/src/features/favorites/domain/usecases/remove-from-favorites-usecase.ts

@@ -0,0 +1,23 @@
+import { inject, injectable } from "inversify";
+
+import { Usecase } from "@/core/helpers/usecase";
+import { Result } from "@/core/helpers/result";
+import { FavoritesRepository } from "@/features/favorites/domain/repositories/favorites-repository";
+
+@injectable()
+export class RemoveFromFavoritesUsecase implements Usecase<string, void> {
+  constructor(
+    @inject(FavoritesRepository)
+    private readonly favoritesRepository: FavoritesRepository
+  ) {}
+
+  async execute(movieId: string): Promise<Result<void>> {
+    try {
+      await this.favoritesRepository.removeFavorite(movieId);
+
+      return Result.success(null);
+    } catch (error) {
+      return Result.failure(error);
+    }
+  }
+}