Problem Using Stripe Payment In React Native App - asp.net

I am using stripe in React Native App not expo and using .Net Core web api as a backend,
this is my backend code where, stripe customers creates and their ephemeral keys and setup_intent
public Customer create_customer()
{
StripeConfiguration.ApiKey =_appSettings.StripeApiSecret;
var options = new CustomerCreateOptions
{
Description = "My First Test Customer",
};
var service = new CustomerService();
return service.Create(options);
}
public EphemeralKey create_empherical_key(string customerId)
{
var options = new EphemeralKeyCreateOptions
{
StripeVersion = "2020-08-27",
Customer = customerId
};
var service = new EphemeralKeyService();
return service.Create(options);
}
public SetupIntent setup_intent(string customerId)
{
var options = new SetupIntentCreateOptions
{
Customer = customerId
};
var service = new SetupIntentService();
return service.Create(options);
}
my backend is working fine it creates all the values that stripe needs,
main problem is lying here in React Native app
function CheckoutScreen() {
const { initPaymentSheet, presentPaymentSheet } = useStripe();
const [loading, setLoading] = useState(false);
const fetchPaymentSheetParams = async () => {
const response = await fetch(`${ environment.stripeurl +`create_customer`}`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
});
const { setupIntent, ephemeralKey, customer } = await response.json();
return {
setupIntent,
ephemeralKey,
customer,
};
};
const initializePaymentSheet = async () => {
const {
setupIntent,
ephemeralKey,
customer,
} = await fetchPaymentSheetParams();
const { error } = await initPaymentSheet({
customerId: customer.id,
customerEphemeralKeySecret: ephemeralKey.secret,
setupIntentClientSecret: setupIntent.clientSecret,
});
if (!error) {
setLoading(true);
}
};
const openPaymentSheet = async () => {
const { error } = await presentPaymentSheet();
if (error) {
Alert.alert(`Error code: ${error.code}`, error.message);
} else {
Alert.alert('Success', 'Your payment method is successfully set up for future payments!');
}
};
useEffect(() => {
initializePaymentSheet();
}, []);
return (
<View>
<Button
variant="primary"
disabled={!loading}
title="Set up"
onPress={openPaymentSheet}
/>
</View>
);
I receiving all the values of customer, setupintent and ephemeralkey in the front end, when it reach on the line
const { error } = await presentPaymentSheet();
the app crashes.
for refrence I am also providing link of the documentation.
https://stripe.com/docs/payments/save-and-reuse?platform=react-native&ui=payment-sheet
And these are the packages version that I am currently using in this react-native app.
{
"name": "Tookan_App",
"version": "0.0.1",
"private": true,
"scripts": {
"android": "react-native run-android",
"ios": "react-native run-ios",
"start": "react-native start",
"test": "jest",
"lint": "eslint ."
},
"dependencies": {
"#stripe/stripe-react-native": "^0.12.0",
"react": "17.0.2",
"react-native": "0.68.2"
},
"devDependencies": {
"#babel/core": "^7.18.2",
"#babel/runtime": "^7.18.3",
"#react-native-community/eslint-config": "^3.0.2",
"babel-jest": "^28.1.0",
"eslint": "^8.16.0",
"jest": "^28.1.0",
"metro-react-native-babel-preset": "^0.71.0",
"react-test-renderer": "17.0.2"
},
"jest": {
"preset": "react-native"
}
}

Related

Apollo Client is not working with NextJS using SSR

I'm trying to use Apollo Client/Server for my NextJS, and some pages I'm trying to SSR and staticlly generate them, but I'm faing an issue with Apollo where it fails to fetch on server but not when I use the client on the client.
Firstlly this is my package json, where my libs are configed:
{
"name": "landing",
"version": "1.0.0",
"private": true,
"scripts": {
"dev": "next dev -p 9999",
"build": "next build",
"start": "next start -p 9999",
"lint": "next lint"
},
"dependencies": {
"#apollo/react-hooks": "^4.0.0",
"#reduxjs/toolkit": "^1.9.0",
"apollo-server-micro": "2.25.1",
"deepmerge": "^4.2.2",
"firebase": "^9.14.0",
"graphql": "^15.5.1",
"loadash": "^1.0.0",
"luxon": "^3.1.1",
"mongoose": "^5.13.15",
"next": "11.0.1",
"next-redux-wrapper": "^8.0.0",
"react": "17.0.2",
"react-dom": "17.0.2",
"react-images-uploading": "^3.1.7",
"react-infinite-scroll-component": "^6.1.0",
"react-redux": "^8.0.5",
"react-tag-input-component": "^2.0.2",
"uuid": "^9.0.0"
},
"devDependencies": {
"autoprefixer": "^10.4.13",
"eslint": "7.32.0",
"eslint-config-next": "11.0.1",
"postcss": "^8.4.19"
}
}
And here is my single API route in pages/api.jsx folder:
import { Connect } from "../utils/Connect";
import { ApolloServer, makeExecutableSchema } from "apollo-server-micro";
import { defs as typeDefs } from "../graphql/defs";
import { resolves as resolvers } from "../graphql/resolves";
Connect();
export const schema = makeExecutableSchema({ typeDefs, resolvers });
const api = { bodyParser: false };
const path = { path: "/api" };
export const config = { api };
export default new ApolloServer({ schema }).createHandler(path);
While this is my Mongo Connection that I imported earlier:
import mongoose from "mongoose";
export const Connect = async () => {
try {
await mongoose.connect(process.env.MONGO_URI, {
useNewUrlParser: true,
useUnifiedTopology: true,
useFindAndModify: false,
useCreateIndex: true,
});
} catch (err) {
console.log(`Something went wrong trying to connect to the database);
process.exit(1);
}
};
While this is my Apollo Client which is configured for Client and Server calls:
import merge from "deepmerge";
import { useMemo } from "react";
import { ApolloClient, HttpLink, InMemoryCache, from } from "#apollo/client";
import { onError } from "#apollo/client/link/error";
import { concatPagination } from "#apollo/client/utilities";
import { isEqual } from "lodash";
export const APOLLO_STATE_PROP_NAME = "__APOLLO_STATE__";
let apolloClient;
const errorLink = onError(({ graphQLErrors, networkError }) => {
if (graphQLErrors) graphQLErrors.forEach(({ message, locations, path }) => {
const msg = `[GraphQL error]: Message: ${message}`;
const lct = `Location: ${locations}`;
const pth = `Path: ${path}`;
console.log(`${msg}, ${lct}, ${pth}`);
});
if (networkError) {
const ntw = `[Network error]: ${networkError}`;
console.log(ntw);
}
});
const httpLink = new HttpLink({
uri: `http://localhost:9999/api`,
credentials: "same-origin",
});
function createApolloClient() {
return new ApolloClient({
ssrMode: typeof window === "undefined",
link: from([errorLink, httpLink]),
cache: new InMemoryCache({
typePolicies: {
Query: {
fields: {
allPosts: concatPagination(),
},
},
},
}),
});
}
export function initializeApollo(initialState = null) {
const _apolloClient = apolloClient ?? createApolloClient();
if (initialState) {
const existingCache = _apolloClient.extract();
const data = merge(existingCache, initialState, {
arrayMerge: (destinationArray, sourceArray) => [
...sourceArray,
...destinationArray.filter((d) =>
sourceArray.every((s) => !isEqual(d, s))
),
],
});
_apolloClient.cache.restore(data);
}
if (typeof window === "undefined") return _apolloClient;
if (!apolloClient) apolloClient = _apolloClient;
return _apolloClient;
}
export function addApolloState(client, pageProps) {
if (pageProps?.props) pageProps.props[APOLLO_STATE_PROP_NAME] = client.cache.extract();
return pageProps;
}
export function useApollo(pageProps) {
const state = pageProps[APOLLO_STATE_PROP_NAME];
const store = useMemo(() => initializeApollo(state), [state]);
return store;
}
And lately, this is my page that is SSR-ing:
import { Category } from "../../ui/pages";
import { addApolloState, initializeApollo } from "../../config/Apollo";
import { Description, Globals, Title } from "../../config/Metas";
import { CATEGORIES, CATEGORY } from "../../graphql/queries";
export async function getStaticPaths() {
let paths = [];
const Apollo = initializeApollo();
const config = { query: CATEGORIES };
const categories = await Apollo.query(config);
paths = categories.data.Categories.map((category) => {
return {
params: {
category: category.Name.toLowerCase(),
...category,
},
};
});
return {
paths,
fallback: false,
};
}
export async function getStaticProps(context) {
const Apollo = initializeApollo();
const slug = context.params.category;
const category = await Apollo.query({
query: CATEGORY,
variables: { slug },
});
if (category) {
const data = { props: { category } };
return addApolloState(Apollo, data);
}
else return {
notFound: true,
};
}
const Route = ({ category }) => {
const { data } = category;
const { Category: Meta } = data;
return (
<>
<Globals />
<Title title={Meta.Name} />
<Description description={Meta.Description} />
<Category />
</>
);
};
export default Route;
All those queries that I call are being tested on the Apollo client on front and they are working, but when I do this and start the server with npm run dev I get a weird error:
[Network error]: TypeError: fetch failed
Error [ApolloError]: fetch failed
at new ApolloError (/Users/bfzli/Code/landdding/node_modules/#apollo/client/errors/errors.cjs:34:28)
at /Users/bf/Code/landing/node_modules/#apollo/client/core/core.cjs:1800:19
at both (/Users/bf/Code/landing/node_modules/#apollo/client/utilities/utilities.cjs:997:53)
at /Users/bf/Code/landing/node_modules/#apollo/client/utilities/utilities.cjs:990:72
at new Promise (<anonymous>)
at Object.then (/Users/bf/Code/landing/node_modules/#apollo/client/utilities/utilities.cjs:990:24)
at Object.error (/Users/bf/Code/landing/node_modules/#apollo/client/utilities/utilities.cjs:998:49)
at notifySubscription (/Users/bf/Code/landing/node_modules/zen-observable/lib/Observable.js:140:18)
at onNotify (/Users/bf/Code/landing/node_modules/zen-observable/lib/Observable.js:179:3)
at SubscriptionObserver.error (/Users/bf/Code/landing/node_modules/zen-observable/lib/Observable.js:240:7) {
type: 'ApolloError',
graphQLErrors: [],
clientErrors: [],
networkError: {
cause: {
errno: -61,
code: 'ECONNREFUSED',
syscall: 'connect',
address: '::1',
port: 9999
}
}
}

firebase.database.ServerValue.TIMESTAMP : database is undefined

It's been days and I still can't figure out why firebase.database is undefined.
chat.js file content
const firebase = require('firebase');
require('firebase/database');
exports.sendMessage = (firebaseRtDb, uid, roomPath, message) => firebaseRtDb.ref(`${roomPath}/messages`).push().set({
participant: uid,
date: firebase.database.ServerValue.TIMESTAMP,
message,
});
chat.spec.js extract
const firebase = require('#firebase/testing');
const { sendMessage } = require('./chat');
const getRtDb = async (projectId, databaseName, auth) => {
const app = firebase.initializeTestApp(
{
projectId,
databaseName,
auth,
},
);
const adminApp = firebase.initializeAdminApp({ databaseName });
const adminDb = adminApp.database();
await firebase
.loadDatabaseRules({
databaseName,
rules: JSON.stringify(rules),
});
const db = app.database();
return [db, adminDb];
};
let db = null;
let adminDb = null;
const myUid = 'lul';
beforeEach(async () => {
const [rtDb, rtAdminDb] = await getRtDb('quickChat', 'quickChat', { uid: myUid });
db = rtDb;
adminDb = rtAdminDb;
});
afterEach(async () => adminDb.ref('/').set(null));
it('Can write to chat', async () => {
const roomPath = 'chatsRooms/room1';
await adminDb.ref(roomPath).set({
participants: {
[myUid]: true,
},
});
return firebase.assertSucceeds(sendMessage(db, myUid, roomPath, 'lol'));
});
I tried replacing const firebase = require('firebase'); by onst firebase = require('firebase/app'); and with and without require('firebase/database');.
With code as is in this post, my IDE recognise firebase.database.ServerValue.TIMESTAMP. But Jest test fails.
I started the project using npx degit sveltejs/template my-svelte-project.
Jest output
● Chat › Participants › Can write to chat
TypeError: Cannot read property 'ServerValue' of undefined
4 | exports.sendMessage = (firebaseRtDb, uid, roomPath, message) => firebaseRtDb.ref(`${roomPath}/messages`).push().set({
5 | participant: uid,
> 6 | date: firebase.database.ServerValue.TIMESTAMP,
| ^
7 | message,
8 | });
9 |
at sendMessage (src/lib/chat.js:6:27)
at Object.<anonymous> (src/lib/chat.spec.js:56:38)
package.json
{
"name": "svelte-app",
"version": "1.0.0",
"scripts": {
"build": "rollup -c",
"dev": "rollup -c -w",
"start": "sirv public",
"test": "jest --detectOpenHandles",
"test:watch": "jest --watchAll",
"test:ci": "jest --runInBand"
},
"devDependencies": {
"#firebase/testing": "^0.20.11",
"#rollup/plugin-commonjs": "^16.0.0",
"#rollup/plugin-node-resolve": "^10.0.0",
"eslint": "^7.16.0",
"eslint-config-airbnb-base": "^14.2.1",
"eslint-plugin-import": "^2.22.1",
"eslint-plugin-jest": "^24.1.3",
"eslint-plugin-promise": "^4.2.1",
"jest": "^26.6.3",
"rollup": "^2.3.4",
"rollup-plugin-css-only": "^3.1.0",
"rollup-plugin-livereload": "^2.0.0",
"rollup-plugin-svelte": "^7.0.0",
"rollup-plugin-terser": "^7.0.0",
"svelte": "^3.0.0"
},
"dependencies": {
"firebase": "^8.2.1",
"sirv-cli": "^1.0.0"
}
}
EDIT 1 : forgot to add getRtDb() definition
The dependency #firebase/testing was the cause. It is deprecated and I had to replace it by #firebase/rules-unit-testing.
I also switched to Typescript and made the import as follow:
chat.spec.ts
import * as firebase from '#firebase/rules-unit-testing';
import rules from '../../database.rules.json';
import { sendMessage } from './chat';
chat.ts
import firebase from 'firebase/app';
import 'firebase/database';

Does http-proxy-middleware work with Serverless Lambda?

I'm trying to proxy an external API through Serverless Lambda. Trying the following example for the code below: http://localhost:3000/users/1 returns 200 but body is empty. I must be overlooking something as http://localhost:3000/users/11 returns a 404 (as expected).
index.js
'use strict';
const serverless = require('serverless-http');
const express = require('express');
const {
createProxyMiddleware
} = require('http-proxy-middleware');
const app = express();
const jsonPlaceholderProxy = createProxyMiddleware({
target: 'http://jsonplaceholder.typicode.com',
changeOrigin: true,
logLevel: 'debug'
});
app.use('/users', jsonPlaceholderProxy);
app.get('/', (req, res) => {
res.json({
msg: 'Hello from Serverless!'
})
})
const handler = serverless(app);
module.exports.handler = async (event, context) => {
try {
const result = await handler(event, context);
return result;
} catch (error) {
return error;
}
};
serverless.yml
service: sls-proxy-test
provider:
name: aws
runtime: nodejs12.x
plugins:
- serverless-offline
functions:
app:
handler: index.handler
events:
- http:
method: ANY
path: /
- http: "ANY {proxy+}"
package.json
{
"name": "proxy",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"sls": "sls",
"offline": "sls offline start"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
"express": "4.17.1",
"http-proxy-middleware": "1.0.1",
"serverless-http": "2.3.2"
},
"devDependencies": {
"serverless": "1.65.0",
"serverless-offline": "5.12.1"
}
}
try to remove the transfer-encoding header from the response in onProxyRes listener inside createProxyMiddleware
const jsonPlaceholderProxy = createProxyMiddleware({
onProxyRes: function (proxyRes, req, res) { // listener on response
delete proxyRes.headers['transfer-encoding']; // remove header from response
},
// remaining code
I had the same issue but adding the below onProxyRes option solved it
onProxyRes(proxyRes, req, res) {
const bodyChunks = [];
proxyRes.on('data', (chunk) => {
bodyChunks.push(chunk);
});
proxyRes.on('end', () => {
const body = Buffer.concat(bodyChunks);
res.status(proxyRes.statusCode);
Object.keys(proxyRes.headers).forEach((key) => {
res.append(key, proxyRes.headers[key]);
});
res.send(body);
res.end();
});
}

Firebase: TypeError: Cannot read property 'getApplicationDefault' of undefined (Cloud ML Engine)

I am new to Firebase, and am testing a Google ML Engine model which I recently deployed. I was trying to follow instructions from this repo: https://github.com/sararob/tswift-detection and was able to deploy the firebase solution as recommended. But when I run the function on Firebase (I upload an image to images folder in Firebase storage), I get an error which states:
Error occurred: TypeError: Cannot read property 'getApplicationDefault' of undefined
at Promise (/user_code/index.js:24:20)
at cmlePredict (/user_code/index.js:23:12)
at file.download.then.then.then (/user_code/index.js:110:20)
at process._tickDomainCallback (internal/process/next_tick.js:135:7)
Here is the firebase function for reference:
// // Create and Deploy Your First Cloud Functions
// // https://firebase.google.com/docs/functions/write-firebase-functions
//
// exports.helloWorld = functions.https.onRequest((request, response) => {
// response.send("Hello from Firebase!");
// });
'use strict';
const functions = require('firebase-functions');
const gcs = require('#google-cloud/storage');
const admin = require('firebase-admin');
const exec = require('child_process').exec;
const path = require('path');
const fs = require('fs');
const google = require('googleapis');
const sizeOf = require('image-size');
admin.initializeApp(functions.config().firebase);
const db = admin.firestore();
function cmlePredict(b64img) {
return new Promise((resolve, reject) => {
google.auth.getApplicationDefault(function (err, authClient) {
if (err) {
reject(err);
}
if (authClient.createScopedRequired && authClient.createScopedRequired()) {
authClient = authClient.createScoped([
'https://www.googleapis.com/auth/cloud-platform'
]);
}
var ml = google.ml({
version: 'v1'
});
const params = {
auth: authClient,
name: 'projects/xx/models/xx',
resource: {
instances: [
{
"inputs": {
"b64": b64img
}
}
]
}
};
ml.projects.predict(params, (err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
});
});
});
}
function resizeImg(filepath) {
return new Promise((resolve, reject) => {
exec(`convert ${filepath} -resize 600x ${filepath}`, (err) => {
if (err) {
console.error('Failed to resize image', err);
reject(err);
} else {
console.log('resized image successfully');
resolve(filepath);
}
});
});
}
exports.runPrediction = functions.storage.object().onChange((event) => {
fs.rmdir('./tmp/', (err) => {
if (err) {
console.log('error deleting tmp/ dir');
}
});
const object = event.data;
const fileBucket = object.bucket;
const filePath = object.name;
const bucket = gcs().bucket(fileBucket);
const fileName = path.basename(filePath);
const file = bucket.file(filePath);
if (filePath.startsWith('images/')) {
const destination = '/tmp/' + fileName;
console.log('got a new image', filePath);
return file.download({
destination: destination
}).then(() => {
if(sizeOf(destination).width > 600) {
console.log('scaling image down...');
return resizeImg(destination);
} else {
return destination;
}
}).then(() => {
console.log('base64 encoding image...');
let bitmap = fs.readFileSync(destination);
return new Buffer(bitmap).toString('base64');
}).then((b64string) => {
console.log('sending image to CMLE...');
return cmlePredict(b64string);
}).then((result) => {
let boxes = result.predictions[0].detection_boxes;
let scores = result.predictions[0].detection_scores;
console.log('got prediction with confidence: ',scores[0]);
// Only output predictions with confidence > 70%
if (scores[0] >= 0.7) {
let dimensions = sizeOf(destination);
let box = boxes[0];
let x0 = box[1] * dimensions.width;
let y0 = box[0] * dimensions.height;
let x1 = box[3] * dimensions.width;
let y1 = box[2] * dimensions.height;
// Draw a box on the image around the predicted bounding box
return new Promise((resolve, reject) => {
console.log(destination);
exec(`convert ${destination} -stroke "#39ff14" -strokewidth 10 -fill none -draw "rectangle ${x0},${y0},${x1},${y1}" ${destination}`, (err) => {
if (err) {
console.error('Failed to draw rect.', err);
reject(err);
} else {
console.log('drew the rect');
bucket.upload(destination, {destination: 'test2.jpg'})
resolve(scores[0]);
}
});
});
} else {
return scores[0];
}
})
.then((confidence) => {
let outlinedImgPath = '';
let imageRef = db.collection('predicted_images').doc(filePath.slice(7));
if (confidence > 0.7) {
outlinedImgPath = `outlined_img/${filePath.slice(7)}`;
imageRef.set({
image_path: outlinedImgPath,
confidence: confidence
});
return bucket.upload(destination, {destination: outlinedImgPath});
} else {
imageRef.set({
image_path: outlinedImgPath,
confidence: confidence
});
console.log('No tswift found');
return confidence;
}
})
.catch(err => {
console.log('Error occurred: ',err);
});
} else {
return 'not a new image';
}
});
These are the libraries I am using:
{
"name": "functions",
"description": "Cloud Functions for Firebase",
"scripts": {
"lint": "eslint .",
"serve": "firebase serve --only functions",
"shell": "firebase experimental:functions:shell",
"start": "npm run shell",
"deploy": "firebase deploy --only functions",
"logs": "firebase functions:log"
},
"dependencies": {
"firebase-admin": "5.8.1",
"firebase-functions": "0.8.1",
"googleapis": "^27.0.0",
"image-size": "^0.6.1",
"#google-cloud/storage": "^1.5.1"
},
"devDependencies": {
"eslint": "^4.12.0",
"eslint-plugin-promise": "^3.6.0"
},
"private": true
}
While deploying, I received this warning:
24:43 warning Unexpected function expression prefer-arrow-callback
I just struggled through this too. I seemed to get it working by using the firebase admin instead:
const credential = admin.credential.applicationDefault();

Issue with react native project after react-navigation & expo upgrade

I have the issue below after upgrading my react-native application.
My package.json is shown below
{
"name": "react-native-expo-app",
"version": "0.0.0",
"description": "Hello Expo!",
"author": null,
"private": true,
"main": "node_modules/expo/AppEntry.js",
"dependencies": {
"expo": "^25.0.0",
"firebase": "^4.9.1",
"lodash": "^4.17.4",
"moment": "^2.19.2",
"native-base": "^2.3.2",
"react": "16.2.0",
"react-native": "https://github.com/expo/react-native/archive/sdk-25.0.0.tar.gz",
"react-native-chooser": "^1.6.2",
"react-native-datepicker": "^1.6.0",
"react-native-dropdown": "0.0.6",
"react-native-elements": "^0.16.0",
"react-native-ui-kitten": "^3.0.0",
"react-navigation": "^1.0.0",
"react-navigation-redux-helpers": "^1.0.0",
"react-redux": "^5.0.6",
"redux": "^3.7.2",
"redux-persist": "^4.10.2",
"redux-thunk": "^2.2.0"
}
}
The app seems to be processing subsequent pages while loading the first one as the error message is complaining about HomePage, but it should only be rendering WelcomePage. Please see my App.js code below.
const config = {
key: 'primary',
storage: AsyncStorage
};
const HomeNavigator = TabNavigator({
home: {screen: HomePage},
popular: {screen: PopularPage},
search: {screen: SearchPage},
notifications: {screen: NotificationsPage}
}, {
...TabNavigator.Presets.iOSBottomTabs,
});
const RootNavigator = TabNavigator({
welcome: {screen: WelcomePage},
auth: {screen: AuthPage},
signUp: {screen: SignUpPage},
resetPassword: {screen: ResetPasswordPage},
main: {
screen: DrawerNavigator({
home: {
screen: HomeNavigator,
},
profile: {
screen: ProfilePage,
},
following: {
screen: FollowingPage,
},
bookmarks: {
screen: BookmarksPage,
},
contact: {
screen: ContactPage,
},
info: {
screen: InfoPage,
},
conduct: {
screen: ConductPage,
},
login: {
screen: LoginPage,
},
groupProfile: {
screen: GroupProfilePage
}
},
{
contentComponent: SideMenuPage,
drawerWidth: 250
}
)
}
}, {
tabBarPosition: 'bottom',
backBehavior: 'none',
navigationOptions: {
tabBarVisible: false
},
lazy: true
});
const initialState = RootNavigator.router.getStateForAction(RootNavigator.router.getActionForPathAndParams('welcome'));
const navReducer = (state = initialState, action) => {
const nextState = RootNavigator.router.getStateForAction(action, state);
return nextState || state;
};
const appReducer = combineReducers({
nav: navReducer,
auth,
signUp,
resetPasswordReducer,
home,
popular,
rules,
conduct,
profile
}
);
const middleware = createReactNavigationReduxMiddleware(
"welcome",
state => state.nav,
);
const addListener = createReduxBoundAddListener("welcome");
class AppSupport extends React.Component {
render() {
return (
<RootNavigator navigation={addNavigationHelpers({
// dispatch: this.props.dispatch,
state: this.props.nav,
addListener,
})} />
);
}
}
const mapStateToProps = (state) => ({
nav: state.nav
});
const AppWithNavigationState = connect(mapStateToProps)(AppSupport);
const store = createStore(
appReducer,
applyMiddleware(ReduxThunk),
);
export default class App extends React.Component {
state = {isReady: false};
async componentWillMount() {
const config = {
apiKey: “hidden”,
authDomain: "hidden",
databaseURL: "hidden",
projectId: "hidden",
storageBucket: "hidden",
messagingSenderId: "hidden"
};
firebase.initializeApp(config);
this.setState({isReady: true});
}
render() {
if (this.state.isReady) {
return (
<Provider store={store}>
<AppWithNavigationState />
</Provider>
);
} else {
return <Expo.AppLoading/>
}
}
}
See
The error message indicates that there is no current user on line 17 of HomePage.jsx, where you're trying to use currentUser.displayName.
Most likely (you didn't share the relevant code) you have a direct lookup of the current user, something like:
firebase.auth().currentUser.displayName
You'll want to wrap that in an auth state listener:
firebase.auth().onAuthStateChanged(function(user) {
if (user) {
// User is signed in, get its display name.
}
});
This way the code only runs when there actually is a current user. Also see getting the current user in the Firebase docs.

Resources