pocketbase-react 0.1.13 → 0.1.15

package/src/hooks/useAppContent.ts

@@ -4,12 +4,12 @@ import { ContentContext } from '../context';
 import { Record } from '../interfaces/Record';
 import { StorageService } from '../service/Storage';
 
-export type SubscribeType = () => Promise<void | undefined>
-export type UnsubscribeType = () => void | undefined;
-export type FetchType = () => Promise<void | undefined>
-export type CreateType = (record: {}) => Promise<void | undefined>
-export type UpdateType = (id: string, record: {}) => Promise<void | undefined>
-export type DeleteType = (id: string) => Promise<void | undefined>
+export type SubscribeType = () => Promise<void | undefined>;
+export type UnsubscribeType = () => Promise<void | undefined>;
+export type FetchType = () => Promise<void | undefined>;
+export type CreateType = (record: {}) => Promise<void | undefined>;
+export type UpdateType = (id: string, record: {}) => Promise<void | undefined>;
+export type DeleteType = (id: string) => Promise<void | undefined>;
 
 export interface Actions {
   subscribe: SubscribeType;
@@ -23,43 +23,32 @@ export interface Actions {
 export function useAppContent<T extends Record>(
   collectionName: string,
   initialFetch: boolean = false
-): {records: T[], actions: Actions, isSubscribed: boolean} {
-  const records = (store.useAppSelector((state) => state.reducer.records[collectionName]) ?? []) as T[];
+): { records: T[]; actions: Actions; isSubscribed: boolean } {
+  const records = (store.useAppSelector((state) => state.reducer.records[collectionName]) ??
+    []) as T[];
+  const subscriptions = store.useAppSelector((state) => state.reducer.subscriptions).subscriptions;
   const context = useContext(ContentContext);
 
   useEffect(() => {
     if (initialFetch) {
-      context.actions.fetch(collectionName);
+      context.fetch(collectionName);
     }
   }, [collectionName, initialFetch]);
 
   const [isSubscribed, setIsSubscribed] = useState(false);
-  
-  async function refetchSubscribeState() {
-    const isSubscribed = JSON.parse(await StorageService.get("subscribed") ?? JSON.stringify([])) as string[];
-    setIsSubscribed(isSubscribed.includes(collectionName));
-  }
 
   useEffect(() => {
-    (async () => {
-      await refetchSubscribeState();
-    })();
-  }, [])
-  
+    setIsSubscribed(subscriptions.includes(collectionName));
+  }, [subscriptions]);
 
   const actions: Actions = {
-    subscribe: async () => {
-      await context.actions.subscribe(collectionName)
-      await refetchSubscribeState()
-    },
-    unsubscribe: () => {
-      context.actions.unsubscribe(collectionName)
-      refetchSubscribeState()
-    },
-    fetch: async () => await context.actions.fetch(collectionName),
-    create: async (record: {}) => await context.actions.create(collectionName, record),
-    update: async (id: string, record: {}) => await context.actions.update(collectionName, id, record),
-    delete: async (id: string) => await context.actions.delete(collectionName, id),
+    subscribe: async () => await context.subscribe(collectionName),
+    unsubscribe: async () => await context.unsubscribe(collectionName),
+    fetch: async () => await context.fetch(collectionName),
+    create: async (record: {}) => await context.create(collectionName, record),
+    update: async (id: string, record: {}) => await context.update(collectionName, id, record),
+    delete: async (id: string) => await context.delete(collectionName, id),
   };
+
   return { records, actions, isSubscribed };
 }

package/src/hooks/useClientContext.ts

@@ -7,5 +7,4 @@ const useClientContext = () => {
   return context;
 };
 
-
-export { useClientContext };
+export { useClientContext };

package/src/index.ts

@@ -1,4 +1,4 @@
 export * from './hooks';
 export * from './interfaces';
 export * from './context';
-export * from './store';
+export * from './store';

package/src/interfaces/index.ts

@@ -1 +1 @@
-export * from './Record';
+export * from './Record';

package/src/service/Authentication.ts

@@ -1,9 +1,9 @@
-import PocketBase from "@tobicrain/pocketbase";
+import PocketBase from '@tobicrain/pocketbase';
 
 export class AuthenticationService {
   private client: PocketBase;
   public redirect_url: string;
-  
+
   constructor(client: PocketBase) {
     this.client = client;
     this.redirect_url = '';
@@ -14,37 +14,27 @@ export class AuthenticationService {
   }
 
   async getDataAuth() {
-    await this.client.users.authViaOAuth2(
-      'google',
-      'CODE',
-      'VERIFIER',
-      'REDIRECT_URL'
-    );
+    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
-    );
+    await this.client.users.authViaOAuth2(provider, code, verifier, this.redirect_url);
   }
 
-  async AuthWithEmail(email: string, password: string){
+  async AuthWithEmail(email: string, password: string) {
     await this.client.users.authViaEmail(email, password);
   }
 
-  async RegisterWithEmail(email: string, password: string){
+  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)
+  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

@@ -1,23 +1,29 @@
-import AsyncStorage from "@react-native-async-storage/async-storage";
+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 Constants = {
+    SUBSCRIBED: 'subscribed',
+  };
+
+  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 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);
-        }
+  static async remove(key: string): Promise<void> {
+    if (typeof document !== 'undefined') {
+      return localStorage.removeItem(key);
+    } else {
+      return await AsyncStorage.removeItem(key);
     }
-}
+  }
+}

package/src/store/actions/index.tsx

@@ -1,3 +1,4 @@
 import * as recordsAction from './records';
+import * as subscriptionsAction from './subscriptions';
 
-export { recordsAction };
+export { recordsAction, subscriptionsAction };

package/src/store/actions/records.tsx

@@ -44,11 +44,4 @@ const updateRecord = (key: string, payload: Record) =>
     payload,
   } as RecordAction);
 
-export {
-  setRecords,
-  addRecord,
-  addRecords,
-  deleteRecord,
-  deleteRecords,
-  updateRecord,
-};
+export { setRecords, addRecord, addRecords, deleteRecord, deleteRecords, updateRecord };

package/src/store/actions/subscriptions.tsx

@@ -0,0 +1,22 @@
+import { SubscriptionAction } from '../reducers/subscriptions';
+import * as ReduxType from '../types';
+
+const setSubscriptions = (payload: string[]) =>
+  ({
+    type: ReduxType.SET_SUBSCRIPTIONS,
+    payload,
+  } as SubscriptionAction);
+
+const addSubscription = (payload: string) =>
+  ({
+    type: ReduxType.ADD_SUBSCRIPTION,
+    payload,
+  } as SubscriptionAction);
+
+const deleteSubscription = (payload: string) =>
+  ({
+    type: ReduxType.DELETE_SUBSCRIPTION,
+    payload,
+  } as SubscriptionAction);
+
+export { setSubscriptions, addSubscription, deleteSubscription };

package/src/store/index.ts

@@ -1,4 +1,4 @@
 export * from './actions';
 export * from './reducers';
 export * from './types';
-export * from './store';
+export * from './store';

package/src/store/reducers/index.tsx

@@ -1,12 +1,14 @@
 import { combineReducers } from 'redux';
 import { records } from './records';
+import { subscriptions } from './subscriptions';
 
 export const appReducer = combineReducers({
   records: records,
+  subscriptions: subscriptions,
 });
 
 interface AppReducer {
   records: ReturnType<typeof appReducer>;
 }
 
-export type State = AppReducer;
+export type State = AppReducer;

package/src/store/reducers/records.tsx

@@ -6,7 +6,7 @@ export interface ReduxRecord {
 }
 
 export type RecordAction = {
-  type: ReduxType.Types;
+  type: ReduxType.RecordTypes;
   key: string;
   payload: null | Record | Record[];
 };
@@ -75,4 +75,4 @@ export const records = (state: ReduxRecord = {}, action: RecordAction) => {
     default:
       return state;
   }
-};
+};

package/src/store/reducers/subscriptions.tsx

@@ -0,0 +1,46 @@
+import * as ReduxType from '../types';
+
+export interface ReduxSubscriptions {
+  subscriptions: string[];
+}
+
+export type SubscriptionAction = {
+  type: ReduxType.SubscriptionsTypes;
+  payload: string | string[];
+};
+
+function appendSubscription(subscription: string, subscriptions: string[]): string[] {
+  return [...subscriptions, subscription];
+}
+
+function deleteSubscription(subscription: string, subscriptions: string[]): string[] {
+  return subscriptions.filter((sub) => sub !== subscription);
+}
+
+export const subscriptions = (
+  state: ReduxSubscriptions = {
+    subscriptions: [],
+  },
+  action: SubscriptionAction
+) => {
+  const list = state.subscriptions;
+
+  switch (action.type) {
+    case ReduxType.SET_SUBSCRIPTIONS:
+      if (Array.isArray(action.payload)) {
+        return {
+          subscriptions: action.payload,
+        };
+      }
+    case ReduxType.ADD_SUBSCRIPTION:
+      return {
+        subscriptions: appendSubscription(action.payload as string, list),
+      };
+    case ReduxType.DELETE_SUBSCRIPTION:
+      return {
+        subscriptions: deleteSubscription(action.payload as string, list),
+      };
+    default:
+      return state;
+  }
+};

package/src/store/store.tsx

@@ -4,7 +4,6 @@ import { TypedUseSelectorHook, useSelector } from 'react-redux';
 import { appReducer } from './reducers';
 import thunk from 'redux-thunk';
 import { RecordAction } from './reducers/records';
-import AsyncStorage from '@react-native-async-storage/async-storage';
 import { StorageService } from '../service/Storage';
 
 interface Storage {
@@ -13,22 +12,21 @@ interface Storage {
   removeItem(key: string, ...args: Array<any>): any;
 }
 
-
 const CustomStorage: Storage = {
   getItem: async (key: string, ..._args: Array<any>) => {
     return await StorageService.get(key);
   },
   setItem: async (key: string, value: any, ..._args: Array<any>) => {
-    return StorageService.set(key, value);
+    return await StorageService.set(key, value);
   },
   removeItem: async (key: string, ..._args: Array<any>) => {
-    return StorageService.remove(key);
+    return await StorageService.remove(key);
   },
 };
 
 export const persistConfig = {
   key: 'root',
-  storage: CustomStorage
+  storage: CustomStorage,
 };
 
 const reducer = combineReducers({
@@ -45,7 +43,6 @@ const useAppDispatch = store.dispatch;
 type RootState = ReturnType<typeof store.getState>;
 const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
 
-
 const persistor = persistStore(store);
 
-export { AppDispatch, RootState, useAppDispatch, useAppSelector, store, persistor };
+export { AppDispatch, RootState, useAppDispatch, useAppSelector, store, persistor };

package/src/store/types/index.ts

@@ -5,10 +5,19 @@ export const UPDATE_RECORD = 'UPDATE_RECORD';
 export const DELETE_RECORD = 'DELETE_RECORD';
 export const DELETE_RECORDS = 'DELETE_RECORDS';
 
-export type Types =
+export type RecordTypes =
   | typeof SET_RECORDS
   | typeof ADD_RECORD
   | typeof ADD_RECORDS
   | typeof UPDATE_RECORD
   | typeof DELETE_RECORD
   | typeof DELETE_RECORDS;
+
+export const SET_SUBSCRIPTIONS = 'SET_SUBSCRIPTIONS';
+export const ADD_SUBSCRIPTION = 'ADD_SUBSCRIPTION';
+export const DELETE_SUBSCRIPTION = 'DELETE_SUBSCRIPTION';
+
+export type SubscriptionsTypes =
+  | typeof SET_SUBSCRIPTIONS
+  | typeof ADD_SUBSCRIPTION
+  | typeof DELETE_SUBSCRIPTION;