pocketbase-react 0.1.8 → 0.1.9

package/es/hooks/useAuth.js

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import { AuthContext } from '../context/auth';
+export function useAuth() {
+  const actions = useContext(AuthContext);
+  return {
+    actions
+  };
+}

package/es/service/Authentication.d.ts

@@ -0,0 +1,23 @@
+import PocketBase from "@tobicrain/pocketbase";
+export declare class AuthenticationService {
+    private client;
+    redirect_url: string;
+    constructor(client: PocketBase);
+    getListAuthMethods(): Promise<{
+        [key: string]: any;
+        emailPassword: boolean;
+        authProviders: {
+            name: string;
+            state: string;
+            codeVerifier: string;
+            codeChallenge: string;
+            codeChallengeMethod: string;
+            authUrl: string;
+        }[];
+    }>;
+    getDataAuth(): Promise<void>;
+    AuthWithOauth(provider: string, code: string, verifier: string): Promise<void>;
+    AuthWithEmail(email: string, password: string): Promise<void>;
+    RegisterWithEmail(email: string, password: string): Promise<void>;
+    getUserData(id: string, token: string): Promise<import("@tobicrain/pocketbase").User>;
+}

package/es/service/Authentication.js

@@ -0,0 +1,32 @@
+export class AuthenticationService {
+  constructor(client) {
+    this.client = void 0;
+    this.redirect_url = void 0;
+    this.client = client;
+    this.redirect_url = '';
+  }
+  async getListAuthMethods() {
+    return await this.client.users.listAuthMethods();
+  }
+  async getDataAuth() {
+    await this.client.users.authViaOAuth2('google', 'CODE', 'VERIFIER', 'REDIRECT_URL');
+  }
+  async AuthWithOauth(provider, code, verifier) {
+    await this.client.users.authViaOAuth2(provider, code, verifier, this.redirect_url);
+  }
+  async AuthWithEmail(email, password) {
+    await this.client.users.authViaEmail(email, password);
+  }
+  async RegisterWithEmail(email, password) {
+    await this.client.users.create({
+      email: email,
+      password: password,
+      passwordConfirm: password
+    });
+  }
+  async getUserData(id, token) {
+    const headers = new Headers();
+    headers.append("Authorization", "user " + token);
+    return await this.client.users.getOne(id);
+  }
+}

package/es/service/Storage.d.ts

@@ -0,0 +1,5 @@
+export declare class StorageService {
+    static get(key: string): Promise<string | null>;
+    static set(key: string, value: string): Promise<void>;
+    static remove(key: string): Promise<void>;
+}

package/es/service/Storage.js

@@ -0,0 +1,20 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+export class StorageService {
+  static async get(key) {
+    return typeof document !== 'undefined' ? localStorage.getItem(key) : await AsyncStorage.getItem(key);
+  }
+  static async set(key, value) {
+    if (typeof document !== 'undefined') {
+      return localStorage.setItem(key, value);
+    } else {
+      return await AsyncStorage.setItem(key, value);
+    }
+  }
+  static async remove(key) {
+    if (typeof document !== 'undefined') {
+      return localStorage.removeItem(key);
+    } else {
+      return await AsyncStorage.removeItem(key);
+    }
+  }
+}

package/es/store/store.js

@@ -3,28 +3,16 @@ import { persistStore, persistReducer } from 'redux-persist';
 import { useSelector } from 'react-redux';
 import { appReducer } from './reducers';
 import thunk from 'redux-thunk';
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import { StorageService } from '../service/Storage';
 const CustomStorage = {
-  getItem: async (_key, ..._args) => {
-    if (typeof document !== 'undefined') {
-      return localStorage.getItem(_key);
-    } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      return await AsyncStorage.getItem(_key);
-    }
+  getItem: async (key, ..._args) => {
+    return await StorageService.get(key);
   },
-  setItem: async (_key, _value, ..._args) => {
-    if (typeof document !== 'undefined') {
-      return localStorage.setItem(_key, _value);
-    } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      return await AsyncStorage.setItem(_key, _value);
-    }
+  setItem: async (key, value, ..._args) => {
+    return StorageService.set(key, value);
   },
-  removeItem: async (_key, ..._args) => {
-    if (typeof document !== 'undefined') {
-      return localStorage.removeItem(_key);
-    } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      return await AsyncStorage.removeItem(_key);
-    }
+  removeItem: async (key, ..._args) => {
+    return StorageService.remove(key);
   }
 };
 export const persistConfig = {

package/lib/context/Pocketbase.js

@@ -10,26 +10,24 @@ var _react2 = require("redux-persist/integration/react");
 var store = _interopRequireWildcard(require("../store/store"));
 var _client = require("./client");
 var _content = require("./content");
+var _auth = require("./auth");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 const PocketbaseContext = (0, React.createContext)(null);
 exports.PocketbaseContext = PocketbaseContext;
 const Pocketbase = props => {
-  const [client, setClient] = React.useState(null);
-  (0, React.useEffect)(() => {
-    const client = new _pocketbase.default(props.serverURL);
-    client.admins.authViaEmail(props.credentials.username, props.credentials.password).then(() => {
-      setClient(client);
-    });
-  }, [props.serverURL]);
+  const client = new _pocketbase.default(props.serverURL);
   return client ? /*#__PURE__*/React.createElement(_client.ClientProvider, {
     client: client
   }, /*#__PURE__*/React.createElement(_reactRedux.Provider, {
     store: store.store
   }, /*#__PURE__*/React.createElement(_react2.PersistGate, {
     persistor: store.persistor
+  }, /*#__PURE__*/React.createElement(_auth.AuthProvider, {
+    redirectUrl: props.redirectURL,
+    openURL: props.openURL
   }, /*#__PURE__*/React.createElement(_content.ContentProvider, {
     collections: props.initialCollections
-  }, props.children)))) : null;
+  }, props.children))))) : null;
 };
 exports.Pocketbase = Pocketbase;

package/lib/context/auth.js

@@ -0,0 +1,74 @@
+"use strict";
+
+exports.__esModule = true;
+exports.AuthProvider = exports.AuthContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _useClientContext = require("../hooks/useClientContext");
+var _Storage = require("../service/Storage");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const AuthContext = (0, React.createContext)(null);
+exports.AuthContext = AuthContext;
+const AuthProvider = props => {
+  const client = (0, _useClientContext.useClientContext)();
+  const [authProviders, setAuthProviders] = React.useState();
+  const actions = {
+    registerWithEmail: async (email, password) => {
+      await (client == null ? void 0 : client.users.create({
+        email: email,
+        password: password,
+        passwordConfirm: password
+      }));
+    },
+    signInWithEmail: async (email, password) => {
+      await (client == null ? void 0 : client.users.authViaEmail(email, password));
+    },
+    signInWithProvider: async provider => {
+      const authProvider = authProviders == null ? void 0 : authProviders.find(p => p.name === provider);
+      const url = (authProvider == null ? void 0 : authProvider.authUrl) + props.redirectUrl;
+      await props.openURL(url);
+      await _Storage.StorageService.set('provider', JSON.stringify(authProviders));
+    },
+    submitProviderResult: async url => {
+      const params = new URLSearchParams(url.split('?')[1]);
+      const code = params.get('code');
+      const state = params.get('state');
+      const providersString = await _Storage.StorageService.get('provider');
+      if (providersString) {
+        const providers = JSON.parse(providersString);
+        const authProvider = providers == null ? void 0 : providers.find(p => p.state === state);
+        if (authProvider && code) {
+          await (client == null ? void 0 : client.users.authViaOAuth2(authProvider.name, code, authProvider.codeVerifier, props.redirectUrl));
+        }
+      }
+    },
+    signOut: () => {
+      client == null ? void 0 : client.authStore.clear();
+    },
+    sendPasswordResetEmail: async email => {
+      await (client == null ? void 0 : client.users.requestPasswordReset(email));
+    },
+    sendEmailVerification: async email => {
+      await (client == null ? void 0 : client.users.requestVerification(email));
+    },
+    updateProfile: async (id, record) => {
+      await (client == null ? void 0 : client.records.update('profiles', id, record));
+    },
+    updateEmail: async email => {
+      await (client == null ? void 0 : client.users.requestEmailChange(email));
+    },
+    deleteUser: async id => {
+      await (client == null ? void 0 : client.users.delete(id));
+    }
+  };
+  React.useEffect(() => {
+    (async () => {
+      const methods = await (client == null ? void 0 : client.users.listAuthMethods());
+      setAuthProviders(methods == null ? void 0 : methods.authProviders);
+    })();
+  }, [props.redirectUrl]);
+  return /*#__PURE__*/React.createElement(AuthContext.Provider, {
+    value: actions
+  }, props.children);
+};
+exports.AuthProvider = AuthProvider;

package/lib/context/index.js

@@ -23,6 +23,17 @@ Object.keys(_client).forEach(function (key) {
     }
   });
 });
+var _auth = require("./auth");
+Object.keys(_auth).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _auth[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _auth[key];
+    }
+  });
+});
 var _Pocketbase = require("./Pocketbase");
 Object.keys(_Pocketbase).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/hooks/index.js

@@ -22,4 +22,15 @@ Object.keys(_useClientContext).forEach(function (key) {
       return _useClientContext[key];
     }
   });
+});
+var _useAuth = require("./useAuth");
+Object.keys(_useAuth).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useAuth[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useAuth[key];
+    }
+  });
 });

package/lib/hooks/useAuth.js

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.useAuth = useAuth;
+var _react = require("react");
+var _auth = require("../context/auth");
+function useAuth() {
+  const actions = (0, _react.useContext)(_auth.AuthContext);
+  return {
+    actions
+  };
+}

package/lib/service/Authentication.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports.AuthenticationService = void 0;
+class AuthenticationService {
+  constructor(client) {
+    this.client = void 0;
+    this.redirect_url = void 0;
+    this.client = client;
+    this.redirect_url = '';
+  }
+  async getListAuthMethods() {
+    return await this.client.users.listAuthMethods();
+  }
+  async getDataAuth() {
+    await this.client.users.authViaOAuth2('google', 'CODE', 'VERIFIER', 'REDIRECT_URL');
+  }
+  async AuthWithOauth(provider, code, verifier) {
+    await this.client.users.authViaOAuth2(provider, code, verifier, this.redirect_url);
+  }
+  async AuthWithEmail(email, password) {
+    await this.client.users.authViaEmail(email, password);
+  }
+  async RegisterWithEmail(email, password) {
+    await this.client.users.create({
+      email: email,
+      password: password,
+      passwordConfirm: password
+    });
+  }
+  async getUserData(id, token) {
+    const headers = new Headers();
+    headers.append("Authorization", "user " + token);
+    return await this.client.users.getOne(id);
+  }
+}
+exports.AuthenticationService = AuthenticationService;

package/lib/service/Storage.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.StorageService = void 0;
+var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
+class StorageService {
+  static async get(key) {
+    return typeof document !== 'undefined' ? localStorage.getItem(key) : await _asyncStorage.default.getItem(key);
+  }
+  static async set(key, value) {
+    if (typeof document !== 'undefined') {
+      return localStorage.setItem(key, value);
+    } else {
+      return await _asyncStorage.default.setItem(key, value);
+    }
+  }
+  static async remove(key) {
+    if (typeof document !== 'undefined') {
+      return localStorage.removeItem(key);
+    } else {
+      return await _asyncStorage.default.removeItem(key);
+    }
+  }
+}
+exports.StorageService = StorageService;

package/lib/store/store.js

@@ -8,28 +8,16 @@ var _reduxPersist = require("redux-persist");
 var _reactRedux = require("react-redux");
 var _reducers = require("./reducers");
 var _reduxThunk = _interopRequireDefault(require("redux-thunk"));
-var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
+var _Storage = require("../service/Storage");
 const CustomStorage = {
-  getItem: async (_key, ..._args) => {
-    if (typeof document !== 'undefined') {
-      return localStorage.getItem(_key);
-    } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      return await _asyncStorage.default.getItem(_key);
-    }
+  getItem: async (key, ..._args) => {
+    return await _Storage.StorageService.get(key);
   },
-  setItem: async (_key, _value, ..._args) => {
-    if (typeof document !== 'undefined') {
-      return localStorage.setItem(_key, _value);
-    } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      return await _asyncStorage.default.setItem(_key, _value);
-    }
+  setItem: async (key, value, ..._args) => {
+    return _Storage.StorageService.set(key, value);
   },
-  removeItem: async (_key, ..._args) => {
-    if (typeof document !== 'undefined') {
-      return localStorage.removeItem(_key);
-    } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      return await _asyncStorage.default.removeItem(_key);
-    }
+  removeItem: async (key, ..._args) => {
+    return _Storage.StorageService.remove(key);
   }
 };
 const persistConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pocketbase-react",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Unofficial React SDK (React, React Native, Expo) for interacting with the PocketBase JS SDK",
   "keywords": [
     "pocketbase",

package/src/context/Pocketbase.tsx

@@ -6,35 +6,30 @@ import { PersistGate } from 'redux-persist/integration/react';
 import * as store from '../store/store';
 import { ClientProvider } from './client';
 import { ContentProvider } from './content';
+import { AuthProvider } from './auth';
 
 export const PocketbaseContext = createContext<PocketBase | null>(null);
 
 export type PocketbaseProviderProps = {
   children: React.ReactNode;
   serverURL: string;
-  credentials: {
-    username: string;
-    password: string;
-  };
+  redirectURL: string;
+  openURL: (url: string) => Promise<void>;
   initialCollections?: string[];
 };
 
 export const Pocketbase = (props: PocketbaseProviderProps) => {
-  const [client, setClient] = React.useState<PocketBase | null>(null);
-  useEffect(() => {
-    const client = new PocketBase(props.serverURL);
-    client.admins.authViaEmail(props.credentials.username, props.credentials.password).then(() => {
-      setClient(client);
-    });
-  }, [props.serverURL]);
+  const client = new PocketBase(props.serverURL);
 
   return client ? (
     <ClientProvider client={client}>
       <Provider store={store.store}>
         <PersistGate persistor={store.persistor}>
-          <ContentProvider collections={props.initialCollections}>
-            {props.children}
-          </ContentProvider>
+          <AuthProvider redirectUrl={props.redirectURL} openURL={props.openURL} >
+            <ContentProvider collections={props.initialCollections}>
+              {props.children}
+            </ContentProvider>
+          </AuthProvider>
         </PersistGate>
       </Provider>
     </ClientProvider>

package/src/context/auth.tsx

@@ -0,0 +1,113 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as React from 'react';
+import { createContext, useEffect } from 'react';
+import { useClientContext } from '../hooks/useClientContext';
+import { StorageService } from '../service/Storage';
+
+export type AuthProviderInfo = {
+  name: string;
+  state: string;
+  codeVerifier: string;
+  codeChallenge: string;
+  codeChallengeMethod: string;
+  authUrl: string;
+};
+
+export type RegisterWithEmailType = (email: string, password: string) => Promise<void>;
+export type SignInWithEmailType = (email: string, password: string) => Promise<void>;
+export type SignInWithProviderType = (provider: string) => Promise<void>;
+export type SubmitProviderResultType = (url: string) => Promise<void>;
+export type SignOutType = () => void;
+export type SendPasswordResetEmailType = (email: string) => Promise<void>;
+export type SendEmailVerificationType = (email: string) => Promise<void>;
+export type UpdateProfileType = (id: string, record: {}) => Promise<void>;
+export type UpdateEmailType = (email: string) => Promise<void>;
+export type DeleteUserType = (id: string) => Promise<void>;
+
+export interface AuthActions {
+  registerWithEmail: RegisterWithEmailType
+  signInWithEmail: SignInWithEmailType;
+  signInWithProvider: SignInWithProviderType;
+  submitProviderResult: SubmitProviderResultType;
+  signOut: SignOutType;
+  sendPasswordResetEmail: SendPasswordResetEmailType;
+  sendEmailVerification: SendEmailVerificationType;
+  updateProfile: UpdateProfileType;
+  updateEmail: UpdateEmailType;
+  deleteUser: DeleteUserType;
+}
+
+export const AuthContext = createContext<AuthActions | null>(null);
+
+export type AuthProviderProps = {
+  children: React.ReactNode;
+  redirectUrl: string;
+  openURL: (url: string) => Promise<void>;
+};
+
+
+export const AuthProvider = (props: AuthProviderProps) => {
+  const client = useClientContext();
+  const [authProviders, setAuthProviders] = React.useState<AuthProviderInfo[]>();
+  
+  const actions: AuthActions = {
+    registerWithEmail: async (email, password) => {
+      await client?.users.create({
+        email: email,
+        password: password,
+        passwordConfirm: password,
+      });
+    },
+    signInWithEmail: async (email: string, password: string) => {
+      await client?.users.authViaEmail(email, password);
+    },
+    signInWithProvider: async (provider: string) => {
+      const authProvider = authProviders?.find((p) => p.name === provider);
+      const url = authProvider?.authUrl + props.redirectUrl;
+      await props.openURL(url);
+      await StorageService.set('provider', JSON.stringify(authProviders));
+    },
+    submitProviderResult: async (url: string) => {
+      const params = new URLSearchParams(url.split('?')[1]);
+      const code = params.get('code');
+      const state = params.get('state');
+      const providersString = await StorageService.get('provider');
+      if (providersString) {
+        const providers = JSON.parse(providersString) as AuthProviderInfo[];
+        const authProvider = providers?.find((p) => p.state === state);
+        if (authProvider && code) {
+          await client?.users.authViaOAuth2(authProvider.name, code, authProvider.codeVerifier, props.redirectUrl);
+        }
+      }
+    },
+    signOut: () => {
+      client?.authStore.clear();
+    },
+    sendPasswordResetEmail: async (email: string) => {
+      await client?.users.requestPasswordReset(email);
+    },
+    sendEmailVerification: async (email: string) => {
+      await client?.users.requestVerification(email);
+    },
+    updateProfile: async (id: string, record: {}) => {
+      await client?.records.update('profiles', id, record);
+    },
+    updateEmail: async (email: string) => {
+      await client?.users.requestEmailChange(email);
+    },
+    deleteUser: async (id: string) => {
+      await client?.users.delete(id)
+    }
+  };
+
+  React.useEffect(() => {
+    (async () => {
+      const methods = await client?.users.listAuthMethods();
+      setAuthProviders(methods?.authProviders);
+    })();
+  }, [props.redirectUrl]);
+
+  return (
+    <AuthContext.Provider value={actions}>{props.children}</AuthContext.Provider>
+  );
+};

package/src/context/index.ts

@@ -1,3 +1,4 @@
 export * from './content';
 export * from './client';
-export * from './Pocketbase';
+export * from './auth';
+export * from './Pocketbase';

package/src/hooks/index.ts

@@ -1,2 +1,3 @@
 export * from './useAppContent';
-export * from './useClientContext';
+export * from './useClientContext';
+export * from './useAuth';

package/src/hooks/useAuth.ts

@@ -0,0 +1,7 @@
+import { useContext } from 'react';
+import { AuthActions, AuthContext } from '../context/auth';
+
+export function useAuth(): { actions: AuthActions | null } {
+  const actions = useContext(AuthContext);
+  return { actions };
+}

package/src/service/Authentication.ts

@@ -0,0 +1,50 @@
+import PocketBase from "@tobicrain/pocketbase";
+
+export class AuthenticationService {
+  private client: PocketBase;
+  public redirect_url: string;
+  
+  constructor(client: PocketBase) {
+    this.client = client;
+    this.redirect_url = '';
+  }
+
+  async getListAuthMethods() {
+    return await this.client.users.listAuthMethods();
+  }
+
+  async getDataAuth() {
+    await this.client.users.authViaOAuth2(
+      'google',
+      'CODE',
+      'VERIFIER',
+      'REDIRECT_URL'
+    );
+  }
+  async AuthWithOauth(provider: string, code: string, verifier: string) {
+    await this.client.users.authViaOAuth2(
+      provider,
+      code,
+      verifier,
+      this.redirect_url
+    );
+  }
+
+  async AuthWithEmail(email: string, password: string){
+    await this.client.users.authViaEmail(email, password);
+  }
+
+  async RegisterWithEmail(email: string, password: string){
+    await this.client.users.create({
+      email: email,
+      password: password,
+      passwordConfirm: password,
+  });
+  }
+
+  async getUserData(id:string, token:string) {
+    const headers = new Headers()
+    headers.append("Authorization","user "+token)
+    return await this.client.users.getOne(id)
+  }
+}

package/src/service/Storage.ts

@@ -0,0 +1,23 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+export class StorageService {
+    static async get(key: string): Promise<string | null> {
+        return typeof document !== 'undefined' ? localStorage.getItem(key) : await AsyncStorage.getItem(key);
+    }
+
+    static async set(key: string, value: string): Promise<void> {
+        if (typeof document !== 'undefined') {
+            return localStorage.setItem(key, value);
+        } else {
+            return await AsyncStorage.setItem(key, value);
+        }
+    }
+
+    static async remove(key: string): Promise<void> {
+        if (typeof document !== 'undefined') {
+            return localStorage.removeItem(key);
+        } else {
+            return await AsyncStorage.removeItem(key);
+        }
+    }
+}