pocketbase-react 0.1.19 → 0.1.21

package/src/context/Pocketbase.tsx

@@ -1,12 +1,13 @@
 import * as React from 'react';
 import { createContext, useEffect } from 'react';
-import PocketBase from '@tobicrain/pocketbase';
+import PocketBase, { Admin, BaseAuthStore, LocalAuthStore, User } from '@tobicrain/pocketbase';
 import { Provider } from 'react-redux';
 import { PersistGate } from 'redux-persist/integration/react';
-import * as store from '../store/store';
+import { store, persistor } from '../store/store';
 import { ClientProvider } from './client';
 import { ContentProvider } from './content';
 import { AuthProvider } from './auth';
+import { StorageService } from '../service/Storage';
 
 export const PocketbaseContext = createContext<PocketBase | null>(null);
 
@@ -20,19 +21,31 @@ export type PocketbaseProviderProps = {
 };
 
 export const Pocketbase = (props: PocketbaseProviderProps) => {
-  const client = new PocketBase(props.serverURL);
+  const [client, setClient] = React.useState<PocketBase | null>(null);
+  const [initialCollections, setInitialCollections] = React.useState<string[]>();
+  useEffect(() => {
+    const client = new PocketBase(props.serverURL);
+    client.authStore.onChange(async () => {
+      await StorageService.set(StorageService.Constants.COOKIE, client.authStore.exportToCookie());
+      setInitialCollections(props.initialCollections);
+    });
+    StorageService.get(StorageService.Constants.COOKIE).then((cookie) => {
+      if (cookie) {
+        client.authStore.loadFromCookie(cookie);
+      }
+      setClient(client);
+    });
+  }, [props.serverURL]);
 
   return client ? (
     <ClientProvider client={client}>
-      <Provider store={store.store}>
-        <PersistGate persistor={store.persistor}>
+      <Provider store={store}>
+        <PersistGate persistor={persistor}>
           <AuthProvider
             webRedirectUrl={props.webRedirectUrl}
             mobileRedirectUrl={props.mobileRedirectUrl}
             openURL={props.openURL}>
-            <ContentProvider collections={props.initialCollections}>
-              {props.children}
-            </ContentProvider>
+            <ContentProvider collections={initialCollections}>{props.children}</ContentProvider>
           </AuthProvider>
         </PersistGate>
       </Provider>

package/src/context/auth.tsx

@@ -1,7 +1,5 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { Admin, User } from '@tobicrain/pocketbase';
 import * as React from 'react';
-import { createContext, useEffect } from 'react';
+import { createContext } from 'react';
 import { useClientContext } from '../hooks/useClientContext';
 import { StorageService } from '../service/Storage';
 

package/src/hooks/useAppContent.ts

@@ -3,6 +3,7 @@ import * as store from '../store';
 import { ContentContext } from '../context';
 import { Record } from '../interfaces/Record';
 import { StorageService } from '../service/Storage';
+import { useAppSelector } from '../store';
 
 export type SubscribeType = () => Promise<void | undefined>;
 export type UnsubscribeType = () => Promise<void | undefined>;
@@ -24,9 +25,8 @@ 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[];
-  const subscriptions = store.useAppSelector((state) => state.reducer.subscriptions).subscriptions;
+  const records = useAppSelector((state) => state.reducer.records[collectionName]) as T[];
+  const subscriptions = useAppSelector((state) => state.reducer.subscriptions);
   const context = useContext(ContentContext);
 
   useEffect(() => {

package/src/hooks/useAuth.ts

@@ -1,6 +1,7 @@
 import { Admin, User } from '@tobicrain/pocketbase';
 import { useContext, useEffect, useState } from 'react';
 import { AuthActions, AuthContext } from '../context/auth';
+import { StorageService } from '../service/Storage';
 import { useClientContext } from './useClientContext';
 
 export interface AuthContextInterface {
@@ -18,6 +19,10 @@ export function useAuth(): AuthContextInterface {
   function updateAuth() {
     setIsSignedIn(client?.authStore.token !== '');
     setUser(client?.authStore.model ?? null);
+    const cookie = client?.authStore.exportToCookie();
+    if (cookie) {
+      StorageService.set(StorageService.Constants.COOKIE, cookie);
+    }
   }
 
   useEffect(() => {

package/src/service/Storage.ts

@@ -3,6 +3,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 export class StorageService {
   static Constants = {
     SUBSCRIBED: 'subscribed',
+    COOKIE: 'cookie',
   };
 
   static async get(key: string): Promise<string | null> {

package/src/store/reducers/index.tsx

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

package/src/store/reducers/subscriptions.tsx

@@ -1,46 +1,29 @@
 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];
+  return subscriptions.includes(subscription) ? subscriptions : [...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;
-
+export const subscriptions = (state: string[] = [], action: SubscriptionAction) => {
   switch (action.type) {
     case ReduxType.SET_SUBSCRIPTIONS:
       if (Array.isArray(action.payload)) {
-        return {
-          subscriptions: action.payload,
-        };
+        return action.payload as string[];
       }
     case ReduxType.ADD_SUBSCRIPTION:
-      return {
-        subscriptions: appendSubscription(action.payload as string, list),
-      };
+      return appendSubscription(action.payload as string, state) as string[];
     case ReduxType.DELETE_SUBSCRIPTION:
-      return {
-        subscriptions: deleteSubscription(action.payload as string, list),
-      };
+      return deleteSubscription(action.payload as string, state) as string[];
     default:
-      return state;
+      return state as string[];
   }
 };

package/es/service/Authentication.d.ts

@@ -1,23 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/lib/service/Authentication.js

@@ -1,37 +0,0 @@
-"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/src/service/Authentication.ts

@@ -1,40 +0,0 @@
-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);
-  }
-}