Implement Sign Up, Login, Logout, and Authentication Flow

.env.development

@@ -0,0 +1 @@
+REACT_APP_API_URL = http://localhost:5000/api/v1

.github/workflows/build-deploy-neurojsonio.yml

@@ -24,7 +24,10 @@ jobs:
       - name: Build React App for production
         run: |
           echo "Building for production at root /"
-          PUBLIC_URL="/" yarn build
+          # PUBLIC_URL="/" yarn build
+          export PUBLIC_URL="/"
+          export REACT_APP_API_URL="/api/v1"
+          yarn build
 
       - name: Copy JS libraries
         run: |

.github/workflows/build-deploy-zodiac.yml

@@ -33,7 +33,10 @@ jobs:
       - name: Build React App with Dynamic PUBLIC_URL
         run: |
           echo "Building for /dev/${{ env.BRANCH_NAME }}/"
-          PUBLIC_URL="/dev/${{ env.BRANCH_NAME }}/" yarn build
+          # PUBLIC_URL="/dev/${{ env.BRANCH_NAME }}/" yarn build
+          export PUBLIC_URL="/dev/${{ env.BRANCH_NAME }}/"
+          export REACT_APP_API_URL="/dev/${{ env.BRANCH_NAME }}/api/v1"
+          yarn build
 
       - name: Copy JS libraries (jdata, bjdata etc.)
         run: |

.gitignore

@@ -1,4 +1,7 @@
 .env
+.env.local
+.env.*.local
+.env.production
 node_modules
 .DS_Store
 package-lock.json
@@ -8,5 +11,8 @@ build
 #backend
 backend/node_modules/
 backend/.env
+backend/.env.local
+backend/.env.*.local
 backend/*.sqlite
+backend/*.db
 !backend/package-lock.json

backend/config/passport.config.js

@@ -0,0 +1,160 @@
+// backend/config/passport.config.js
+const passport = require("passport");
+const GoogleStrategy = require("passport-google-oauth20").Strategy;
+// const { User } = require("../models");
+const User = require("../src/models/User");
+
+// Google OAuth Strategy
+passport.use(
+  new GoogleStrategy(
+    {
+      clientID: process.env.GOOGLE_CLIENT_ID,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+      callbackURL:
+        process.env.GOOGLE_CALLBACK_URL ||
+        "http://localhost:5000/api/v1/auth/google/callback",
+      scope: ["profile", "email"],
+    },
+    async (accessToken, refreshToken, profile, done) => {
+      try {
+        // Extract user info from Google profile
+        const email = profile.emails[0].value;
+        const googleId = profile.id;
+        const username = profile.displayName || email.split("@")[0];
+
+        // NEW: Extract name from Google profile
+        const firstName = profile.name?.givenName || "";
+        const lastName = profile.name?.familyName || "";
+
+        // Check if user already exists with this Google ID
+        let user = await User.findOne({
+          where: { google_id: googleId },
+        });
+
+        if (user) {
+          // User exists, return user
+          return done(null, user);
+        }
+
+        // Check if user exists with this email (linking accounts)
+        user = await User.findOne({
+          where: { email },
+        });
+
+        if (user) {
+          // User exists with email but no Google ID - link the accounts
+          user.google_id = googleId;
+          // NEW: Update profile fields if they were empty
+          if (!user.first_name && firstName) user.first_name = firstName;
+          if (!user.last_name && lastName) user.last_name = lastName;
+          await user.save();
+          return done(null, user);
+        }
+
+        // Create new user
+        user = await User.create({
+          username: username,
+          email: email,
+          google_id: googleId,
+          hashed_password: null, // OAuth users don't have passwords
+          email_verified: true,
+          // Set from Google profile, or empty string if not available
+          first_name: firstName || "",
+          last_name: lastName || "",
+          company: "", // Always empty for new OAuth users - must be completed
+        });
+
+        return done(null, user);
+      } catch (error) {
+        console.error("Google OAuth error:", error);
+        return done(error, null);
+      }
+    }
+  )
+);
+
+// ORCID OAuth Strategy (using OAuth2Strategy as base)
+const OAuth2Strategy = require("passport-oauth2");
+
+// passport.use(
+//   "orcid",
+//   new OAuth2Strategy(
+//     {
+//       authorizationURL: "https://orcid.org/oauth/authorize",
+//       tokenURL: "https://orcid.org/oauth/token",
+//       clientID: process.env.ORCID_CLIENT_ID,
+//       clientSecret: process.env.ORCID_CLIENT_SECRET,
+//       callbackURL: process.env.ORCID_CALLBACK_URL || "http://localhost:5000/api/v1/auth/orcid/callback",
+//       scope: "/authenticate",
+//     },
+//     async (accessToken, refreshToken, params, profile, done) => {
+//       try {
+//         // ORCID returns user info in params, not profile
+//         const orcidId = params.orcid;
+//         const name = params.name || `ORCID User ${orcidId}`;
+
+//         // ORCID doesn't always provide email in the basic scope
+//         // You might need to make an additional API call to get email
+//         // For now, we'll use ORCID ID as identifier
+
+//         // Check if user exists with this ORCID ID
+//         let user = await User.findOne({
+//           where: { orcid_id: orcidId },
+//         });
+
+//         if (user) {
+//           return done(null, user);
+//         }
+
+//         // If we have email from ORCID, check for existing user
+//         if (params.email) {
+//           user = await User.findOne({
+//             where: { email: params.email },
+//           });
+
+//           if (user) {
+//             // Link ORCID to existing account
+//             user.orcid_id = orcidId;
+//             await user.save();
+//             return done(null, user);
+//           }
+//         }
+
+//         // Create new user
+//         // Note: ORCID might not provide email, so we use ORCID ID as part of email
+//         const email = params.email || `${orcidId}@orcid.placeholder`;
+//         const username = name.replace(/\s+/g, "_").toLowerCase() || `orcid_${orcidId}`;
+
+//         user = await User.create({
+//           username: username,
+//           email: email,
+//           orcid_id: orcidId,
+//           hashed_password: null,
+//           email_verified: true,
+//         });
+
+//         return done(null, user);
+//       } catch (error) {
+//         console.error("ORCID OAuth error:", error);
+//         return done(error, null);
+//       }
+//     }
+//   )
+// );
+
+// Serialize user for session
+passport.serializeUser((user, done) => {
+  done(null, user.id);
+});
+
+// Deserialize user from session
+passport.deserializeUser(async (id, done) => {
+  try {
+    const user = await User.findByPk(id);
+    done(null, user);
+  } catch (error) {
+    done(error, null);
+  }
+});
+
+module.exports = passport;

backend/migrations/20251028184256-create-users.js

@@ -45,6 +45,46 @@ module.exports = {
         allowNull: false,
         unique: true,
       },
+      email_verified: {
+        type: Sequelize.BOOLEAN,
+        defaultValue: false,
+        allowNull: false,
+      },
+      verification_token: {
+        type: Sequelize.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+      verification_token_expires: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
+      // NEW FIELDS FOR PASSWORD RESET
+      reset_password_token: {
+        type: Sequelize.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+      reset_password_expires: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
+      first_name: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+      },
+      last_name: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+      },
+      company: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+      },
+      interests: {
+        type: Sequelize.TEXT,
+        allowNull: true,
+      },
       created_at: {
         type: Sequelize.DATE,
         allowNull: false,

backend/models/index.js

@@ -1,37 +1,44 @@
-'use strict';
+"use strict";
 
-const fs = require('fs');
-const path = require('path');
-const Sequelize = require('sequelize');
-const process = require('process');
+const fs = require("fs");
+const path = require("path");
+const Sequelize = require("sequelize");
+const process = require("process");
 const basename = path.basename(__filename);
-const env = process.env.NODE_ENV || 'development';
-const config = require(__dirname + '/../config/config.json')[env];
+const env = process.env.NODE_ENV || "development";
+const config = require(__dirname + "/../config/config.js")[env];
 const db = {};
 
 let sequelize;
 if (config.use_env_variable) {
   sequelize = new Sequelize(process.env[config.use_env_variable], config);
 } else {
-  sequelize = new Sequelize(config.database, config.username, config.password, config);
+  sequelize = new Sequelize(
+    config.database,
+    config.username,
+    config.password,
+    config
+  );
 }
 
-fs
-  .readdirSync(__dirname)
-  .filter(file => {
+fs.readdirSync(__dirname)
+  .filter((file) => {
     return (
-      file.indexOf('.') !== 0 &&
+      file.indexOf(".") !== 0 &&
       file !== basename &&
-      file.slice(-3) === '.js' &&
-      file.indexOf('.test.js') === -1
+      file.slice(-3) === ".js" &&
+      file.indexOf(".test.js") === -1
     );
   })
-  .forEach(file => {
-    const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);
+  .forEach((file) => {
+    const model = require(path.join(__dirname, file))(
+      sequelize,
+      Sequelize.DataTypes
+    );
     db[model.name] = model;
   });
 
-Object.keys(db).forEach(modelName => {
+Object.keys(db).forEach((modelName) => {
   if (db[modelName].associate) {
     db[modelName].associate(db);
   }