@gonextgames/utils 0.0.15

package/dist/client/analytics/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _trackEvent = require("./trackEvent");
+Object.keys(_trackEvent).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _trackEvent[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _trackEvent[key];
+    }
+  });
+});

package/dist/client/analytics/trackEvent.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trackEvent = void 0;
+const trackEvent = function (eventName, eventParams) {
+  if (process.env.ENVIRONMENT === 'development') {
+    const eventKey = `${eventName}-${JSON.stringify(eventParams)}`;
+    if (window._lastTrackedEvent === eventKey) {
+      return;
+    }
+    window._lastTrackedEvent = eventKey;
+  }
+
+  // console.log('trackEvent', eventName, eventParams);
+  if (typeof window !== 'undefined' && window.gtag) {
+    window.gtag('event', eventName, eventParams);
+  }
+};
+exports.trackEvent = trackEvent;

package/dist/client/auth/authStore.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAuthStore = void 0;
+var _zustand = require("zustand");
+const useAuthStore = exports.useAuthStore = (0, _zustand.create)(set => ({
+  user: null,
+  isAuthenticated: false,
+  isLoading: false,
+  refreshing: false,
+  lastVerified: null,
+  error: null,
+  setAuth: user => {
+    set({
+      user,
+      isAuthenticated: true,
+      isLoading: false
+    });
+  },
+  clearAuth: () => {
+    set({
+      user: null,
+      isAuthenticated: false,
+      isLoading: false
+    });
+  },
+  setLoading: loading => {
+    set({
+      isLoading: loading
+    });
+  }
+}));

package/dist/client/auth/index.js

@@ -0,0 +1,157 @@
+"use strict";
+"use client";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AuthProvider = AuthProvider;
+exports.useAuth = useAuth;
+var _react = require("react");
+var _navigation = require("next/navigation");
+var _authStore = require("./authStore");
+const AuthContext = /*#__PURE__*/(0, _react.createContext)({});
+function AuthProvider({
+  children
+}) {
+  const {
+    setAuth,
+    clearAuth,
+    setLoading,
+    setError
+  } = (0, _authStore.useAuthStore)();
+  const router = (0, _navigation.useRouter)();
+  (0, _react.useEffect)(() => {
+    // Only check auth on initial mount
+    const initialCheck = async () => {
+      // Skip auth check on login/register pages
+      if (window.location.pathname === '/login' || window.location.pathname === '/register') {
+        setLoading(false);
+        return;
+      }
+      await checkAuth();
+    };
+    initialCheck();
+  }, []);
+  const checkAuth = async () => {
+    const randomNumber = Math.floor(Math.random() * 100);
+    // if (useAuthStore.getState().isLoading) {
+    //   console.warn('[Auth] Already loading', randomNumber)
+    //   return // Prevent concurrent checks
+    // }
+    setLoading(true);
+    try {
+      const response = await fetch('/api/auth/verify', {
+        credentials: 'include'
+      });
+      if (!response.ok) {
+        console.warn('[Auth] Verification failed', randomNumber);
+        throw new Error('Verification failed', randomNumber);
+      }
+      const data = await response.json();
+      console.log('[Auth] Verification successful', data);
+      if (!data.authenticated) {
+        console.warn('[Auth] Not authenticated', randomNumber);
+        clearAuth();
+        return;
+      }
+      if (!data.user || !data.user.user_id) {
+        console.warn('[Auth] Invalid user data', randomNumber);
+        throw new Error('Invalid user data', randomNumber);
+      }
+      setAuth(data.user);
+    } catch (error) {
+      console.error('[Auth] Check failed:', error, randomNumber);
+      setError(error);
+      clearAuth();
+    } finally {
+      setLoading(false);
+    }
+  };
+  const login = async (email, password) => {
+    try {
+      const response = await fetch('/api/auth/login', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          email,
+          password
+        })
+      });
+      if (!response.ok) throw new Error('Login failed');
+      const data = await response.json();
+      await setAuth(data.user);
+
+      // Verify auth state is set
+      const verifyResponse = await fetch('/api/auth/verify');
+      if (!verifyResponse.ok) throw new Error('Auth verification failed');
+    } catch (error) {
+      clearAuth();
+      throw error;
+    }
+  };
+  const logout = async () => {
+    try {
+      await fetch('/api/auth/logout', {
+        method: 'POST'
+      });
+    } catch (error) {
+      // Ignore logout errors
+    } finally {
+      clearAuth();
+      router.push('/');
+    }
+  };
+  const register = async userData => {
+    try {
+      const res = await fetch('/api/auth/register', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(userData)
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        throw new Error(data.error || 'Registration failed');
+      }
+      setAuth(data.user);
+    } catch (error) {
+      throw error;
+    }
+  };
+  const value = {
+    isAuthenticated: (0, _authStore.useAuthStore)().isAuthenticated,
+    user: (0, _authStore.useAuthStore)().user,
+    isLoading: (0, _authStore.useAuthStore)().isLoading,
+    login,
+    logout,
+    register
+  };
+  return /*#__PURE__*/React.createElement(AuthContext.Provider, {
+    value: value
+  }, children);
+}
+
+// Export the hook directly with the function declaration
+function useAuth() {
+  const {
+    user,
+    isAuthenticated,
+    isLoading
+  } = (0, _authStore.useAuthStore)();
+  const {
+    login,
+    logout,
+    register
+  } = (0, _react.useContext)(AuthContext);
+  return {
+    user,
+    isAuthenticated,
+    isLoading,
+    login,
+    logout,
+    register
+  };
+}

package/dist/client/components/AdBar.js

@@ -0,0 +1,64 @@
+"use strict";
+'use client';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = AdBar;
+var _react = require("react");
+var _trackEvent = require("../analytics/trackEvent");
+const defaultLinks = [{
+  url: 'https://randomgameidea.com',
+  title: 'Random Game Idea',
+  description: 'Generate unique board game ideas instantly by combining mechanics, themes, and turn orders.'
+}, {
+  url: 'https://templative.net',
+  title: 'Templative',
+  description: 'Batch board game art updates, export to Tabletop Simulator, pdf, and the GameCrafter.'
+}, {
+  url: 'https://playtestfeedback.com',
+  title: 'Playtest Feedback',
+  description: 'Organize playtests, collect feedback, take photos, build your mailing list, and improve your games.'
+}, {
+  url: 'https://boardgameprototypes.com',
+  title: 'Board Game Prototypes',
+  description: 'Share your prototypes and sellsheets with publishers.'
+}];
+function AdBar({
+  via = "",
+  links = defaultLinks,
+  defaultIcon = '/default-favicon.png'
+}) {
+  const [activePopover, setActivePopover] = (0, _react.useState)(null);
+  return /*#__PURE__*/React.createElement("div", {
+    className: "adbar"
+  }, links.map((link, index) => /*#__PURE__*/React.createElement("div", {
+    key: index,
+    className: "adbar-item-wrapper",
+    onMouseEnter: () => setActivePopover(index),
+    onMouseLeave: () => setActivePopover(null)
+  }, /*#__PURE__*/React.createElement("a", {
+    href: link.url + (via ? `?via=${via}` : '')
+    // target="_blank" 
+    // rel="noopener noreferrer"
+    ,
+    onClick: e => {
+      e.preventDefault();
+      (0, _trackEvent.trackEvent)(`adbar_${link.title}_click`);
+      window.location.href = link.url + (via ? `?via=${via}` : '');
+    },
+    className: "adbar-icon"
+  }, /*#__PURE__*/React.createElement("img", {
+    src: `${link.url}/icon.ico`,
+    alt: link.title || `Visit ${link.url}`,
+    onError: e => {
+      e.target.src = defaultIcon;
+    }
+  })), activePopover === index && /*#__PURE__*/React.createElement("div", {
+    className: "custom-popover"
+  }, link.title && /*#__PURE__*/React.createElement("div", {
+    className: "popover-title"
+  }, link.title || new URL(link.url || link).hostname), link.description && /*#__PURE__*/React.createElement("div", {
+    className: "popover-content"
+  }, link.description)))));
+}

package/dist/client/components/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AdBar", {
+  enumerable: true,
+  get: function () {
+    return _AdBar.default;
+  }
+});
+var _AdBar = _interopRequireDefault(require("./AdBar"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/dist/client/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _analytics = require("./analytics");
+Object.keys(_analytics).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _analytics[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _analytics[key];
+    }
+  });
+});
+var _components = require("./components");
+Object.keys(_components).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _components[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _components[key];
+    }
+  });
+});
+var _useStripe = require("./useStripe");
+Object.keys(_useStripe).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useStripe[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useStripe[key];
+    }
+  });
+});

package/dist/client/useStripe.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useStripe = useStripe;
+function useStripe() {
+  const initiateDonation = async (amount = 500) => {
+    try {
+      const response = await fetch('https://api.templative.net/stripe/create-donation-session', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          amount
+        })
+      });
+      const session = await response.json();
+      if (session.error) {
+        throw new Error('Error creating donation session');
+      }
+
+      // Instead of using Stripe.js, directly redirect to the checkout URL
+      window.location.href = session.url;
+    } catch (error) {
+      console.error('Donation process error:', error);
+      alert('Error processing donation');
+    }
+  };
+  return {
+    initiateDonation
+  };
+}

package/dist/server/auth/index.js

@@ -0,0 +1,103 @@
+"use strict";
+'use server';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUserFromToken = getUserFromToken;
+exports.loginWithEmailAndPasswordAndSetToken = loginWithEmailAndPasswordAndSetToken;
+exports.registerUserAndSetToken = registerUserAndSetToken;
+var _users = require("../users");
+var _passwordHashing = require("./passwordHashing.js");
+var _uuid = require("uuid");
+async function getUserFromToken(tableName, tokenName) {
+  try {
+    if (!tableName) throw new Error('Table name is required to getUserFromToken.');
+    const verifiedUser = await getUserIdAndEmailFromToken(tokenName);
+    if (!verifiedUser || !verifiedUser.user_id || !verifiedUser.email) {
+      console.warn('No user ID or email found in token', verifiedUser);
+      return null;
+    }
+    const user = await (0, _users.getUser)(verifiedUser.user_id, tableName);
+    if (!user) {
+      console.warn('User not found in database');
+      cookieStore.delete(tokenName);
+      return null;
+    }
+    if (user.email !== verifiedUser.email) {
+      console.warn('User email mismatch');
+      cookieStore.delete(tokenName);
+      return null;
+    }
+    const {
+      password,
+      ...safeUser
+    } = user;
+    return safeUser;
+  } catch (error) {
+    console.error('Auth check failed:', error.message);
+    return null;
+  }
+}
+async function loginWithEmailAndPasswordAndSetToken(email, password, tableName, tokenName) {
+  try {
+    if (!tableName) throw new Error('Table name is required to loginWithEmailAndPasswordAndSetToken.');
+    if (!tokenName) throw new Error('Token name is required to loginWithEmailAndPasswordAndSetToken.');
+    const user = await (0, _users.getUserByEmail)(email, tableName);
+    if (!user) {
+      console.warn('User not found for email:', email);
+      throw new Error('User not found');
+    }
+    const isValidPassword = await (0, _passwordHashing.comparePasswords)(password, user.password);
+    if (!isValidPassword) {
+      console.warn('Invalid password for user:', email);
+      throw new Error('Invalid password');
+    }
+    await setToken(tokenName, user.user_id, user.email);
+    const {
+      password: _,
+      ...userWithoutPassword
+    } = user;
+    return userWithoutPassword;
+  } catch (error) {
+    console.error('Error in loginWithEmailAndPasswordAndSetToken:', error.message);
+    throw error;
+  }
+}
+async function registerUserAndSetToken(name, email, password, otherData, tableName) {
+  try {
+    if (!tableName) throw new Error('Table name is required');
+
+    // Check if user exists
+    const existingUser = await (0, _users.getUserByEmail)(email, tableName);
+    if (existingUser) {
+      console.warn('Email already registered:', email);
+      throw new Error('Email already registered');
+    }
+
+    // Hash password
+    const hashedPassword = await hashPassword(password);
+
+    // Create user object with user_id
+    const user = {
+      user_id: (0, _uuid.v4)(),
+      name,
+      email: email,
+      contact_email: email,
+      password: hashedPassword
+    };
+    await (0, _users.createUser)(user.user_id, user.name, user.email, user.password, otherData, tableName);
+    await setToken('token', user.user_id, user.email);
+    const {
+      password: _,
+      ...userWithoutPassword
+    } = user;
+    return userWithoutPassword;
+  } catch (error) {
+    console.error('Error in registerUserAndSetToken:', {
+      message: error.message,
+      stack: error.stack
+    });
+    throw new Error('An error occurred while registering the user');
+  }
+}

package/dist/server/auth/passwordHashing.js

@@ -0,0 +1,29 @@
+"use strict";
+'use server';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.comparePasswords = comparePasswords;
+exports.hashPassword = hashPassword;
+var _bcryptjs = _interopRequireDefault(require("bcryptjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function hashPassword(password) {
+  try {
+    return await _bcryptjs.default.hash(password, 10);
+  } catch (error) {
+    console.error('Error in hashPassword:', error);
+    throw error;
+  }
+}
+async function comparePasswords(password, hashedPassword) {
+  try {
+    return await _bcryptjs.default.compare(password, hashedPassword);
+  } catch (error) {
+    console.error('Error in comparePasswords:', {
+      message: error.message,
+      stack: error.stack
+    });
+    throw error;
+  }
+}

package/dist/server/auth/tokens.js

@@ -0,0 +1,46 @@
+"use strict";
+'use server';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUserIdAndEmailFromToken = getUserIdAndEmailFromToken;
+exports.setToken = setToken;
+var _headers = require("next/headers");
+var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const JWT_SECRET = process.env.JWT_SECRET_KEY;
+async function getUserIdAndEmailFromToken(tokenName) {
+  const cookieStore = await (0, _headers.cookies)();
+  const token = cookieStore.get(tokenName)?.value;
+  if (!token) return null;
+  const decodedToken = decodeURIComponent(token);
+  const verifiedUser = _jsonwebtoken.default.verify(decodedToken, JWT_SECRET);
+  if (!verifiedUser || !verifiedUser.user_id || !verifiedUser.exp || !verifiedUser.email) {
+    console.warn('Invalid or expired token', verifiedUser);
+    return null;
+  }
+  const fiveMinutes = 5 * 60 * 1000;
+  if (verifiedUser.exp * 1000 - Date.now() < fiveMinutes) {
+    cookieStore.delete(tokenName);
+    return null;
+  }
+  return verifiedUser;
+}
+async function setToken(tokenName, userId, email) {
+  const payload = {
+    user_id: userId,
+    email: email
+  };
+  const token = _jsonwebtoken.default.sign(payload, JWT_SECRET, {
+    expiresIn: '7d'
+  });
+  const cookieStore = (0, _headers.cookies)();
+  cookieStore.set(tokenName, token, {
+    httpOnly: true,
+    secure: process.env.ENVIRONMENT === 'production',
+    sameSite: 'lax',
+    path: '/',
+    maxAge: 7 * 24 * 60 * 60 // 7 days
+  });
+}

package/dist/server/dynamoDb.js

@@ -0,0 +1,20 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dynamoDb = void 0;
+var _clientDynamodb = require("@aws-sdk/client-dynamodb");
+var _libDynamodb = require("@aws-sdk/lib-dynamodb");
+if (!process.env.AWS_ACCESS_KEY || !process.env.AWS_SECRET) {
+  throw new Error('AWS credentials are not properly configured');
+}
+const client = new _clientDynamodb.DynamoDBClient({
+  region: "us-west-2",
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY,
+    secretAccessKey: process.env.AWS_SECRET
+  }
+});
+const dynamoDb = exports.dynamoDb = _libDynamodb.DynamoDBDocumentClient.from(client);

package/dist/server/email.js

@@ -0,0 +1,48 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sendEmail = sendEmail;
+var _nodemailer = _interopRequireDefault(require("nodemailer"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const GONEXTGAMES_EMAIL = process.env.GONEXTGAMES_EMAIL;
+const GONEXTGAMES_EMAIL_PASSWORD = process.env.GONEXTGAMES_EMAIL_PASSWORD;
+const transporter = _nodemailer.default.createTransport({
+  service: 'gmail',
+  auth: {
+    user: GONEXTGAMES_EMAIL,
+    pass: GONEXTGAMES_EMAIL_PASSWORD
+  }
+});
+async function sendEmail({
+  to,
+  subject,
+  html,
+  unsubscribeToken
+}) {
+  try {
+    var finalHtml = html;
+    if (unsubscribeToken) {
+      const footer = `<p style="font-size: 12px; color: #666;">
+        Our mailing address: 801 W 5th Street Unit 1210, Austin, TX 78703<br>
+        To unsubscribe, <a href="https://templative.net/waitlist/unsubscribe?email=${to}&token=${unsubscribeToken}">click here</a>.</p>`;
+      finalHtml += footer;
+    }
+    const plaintext = finalHtml.replace(/<br\/?>/g, '\n').replace(/<\/p>/g, '\n').replace(/<[^>]*>/g, '').trim();
+    const mailOptions = {
+      from: GONEXTGAMES_EMAIL,
+      to,
+      subject,
+      text: plaintext,
+      html: finalHtml || plaintext
+    };
+    const info = await transporter.sendMail(mailOptions);
+    // console.log('Email sent:', info.messageId);
+    return info;
+  } catch (error) {
+    console.error('Error sending email:', error);
+    throw error;
+  }
+}

package/dist/server/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _dynamoDb = require("./dynamoDb");
+Object.keys(_dynamoDb).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dynamoDb[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dynamoDb[key];
+    }
+  });
+});
+var _email = require("./email");
+Object.keys(_email).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _email[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _email[key];
+    }
+  });
+});
+var _openAI = require("./openAI");
+Object.keys(_openAI).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _openAI[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _openAI[key];
+    }
+  });
+});
+var _s = require("./s3");
+Object.keys(_s).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _s[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _s[key];
+    }
+  });
+});
+var _users = require("./users");
+Object.keys(_users).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _users[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _users[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];
+    }
+  });
+});

package/dist/server/openAI.js

@@ -0,0 +1,32 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getChatCompletion = getChatCompletion;
+var _openai = _interopRequireDefault(require("openai"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const openai = new _openai.default({
+  apiKey: process.env.OPENAI_API_KEY
+});
+async function getChatCompletion(messages) {
+  try {
+    const completion = await openai.chat.completions.create({
+      model: "gpt-4-turbo-preview",
+      messages: [{
+        role: 'system',
+        content: 'When mentioning interesting or important concepts, wrap them in <span> tags. For example: The <span>environmental conditions</span> affect the <span>ecosystem</span>.'
+      }, ...messages.map(msg => ({
+        role: msg.user_id === 'ai' ? 'assistant' : 'user',
+        content: msg.content
+      }))],
+      temperature: 0.7
+    });
+    const content = completion.choices[0].message.content;
+    return content.split('\n').map(line => line.trim()).filter(line => line !== '');
+  } catch (error) {
+    console.error('Error in getChatCompletion:', error);
+    throw error;
+  }
+}

package/dist/server/s3.js

@@ -0,0 +1,93 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateMd5HashFromImage = generateMd5HashFromImage;
+exports.getByGuid = getByGuid;
+exports.uploadImage = uploadImage;
+exports.uploadPdf = uploadPdf;
+var _clientS = require("@aws-sdk/client-s3");
+var _crypto = _interopRequireDefault(require("crypto"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+if (!process.env.AWS_ACCESS_KEY || !process.env.AWS_SECRET) {
+  throw new Error('AWS credentials are not properly configured');
+}
+const s3Client = new _clientS.S3Client({
+  region: "us-west-2",
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY,
+    secretAccessKey: process.env.AWS_SECRET
+  }
+});
+async function getByGuid(bucket, guid) {
+  try {
+    const command = new _clientS.GetObjectCommand({
+      Bucket: bucket,
+      Key: guid
+    });
+    const response = await s3Client.send(command);
+    const str = await response.Body.transformToString();
+    return str;
+  } catch (error) {
+    console.error('Error getting file from S3:', error);
+    throw error;
+  }
+}
+async function generateMd5HashFromImage(buffer) {
+  return _crypto.default.createHash('md5').update(buffer).digest('hex');
+}
+async function uploadImage(imageBuffer, bucket) {
+  try {
+    // Generate MD5 hash for the image
+    const md5Hash = await generateMd5HashFromImage(imageBuffer);
+    const key = `${md5Hash}.png`;
+
+    // Check if image already exists
+    try {
+      const checkCommand = new _clientS.GetObjectCommand({
+        Bucket: bucket,
+        Key: key
+      });
+      await s3Client.send(checkCommand);
+    } catch (error) {
+      if (error.name === 'NoSuchKey') {
+        // Upload the image if it doesn't exist
+        const uploadCommand = new _clientS.PutObjectCommand({
+          Bucket: bucket,
+          Key: key,
+          Body: imageBuffer,
+          ContentType: 'image/png'
+        });
+        await s3Client.send(uploadCommand);
+      } else {
+        throw error;
+      }
+    }
+
+    // Return the URL of the image
+    return `https://${bucket}.s3.amazonaws.com/${key}`;
+  } catch (error) {
+    console.error('Error uploading image:', error);
+    return null;
+  }
+}
+async function uploadPdf(pdfBuffer, filename, bucket) {
+  try {
+    const fileExtension = '.pdf';
+    const randomId = _crypto.default.randomBytes(8).toString('hex');
+    const key = `${randomId}-${filename}`;
+    const uploadCommand = new _clientS.PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: pdfBuffer,
+      ContentType: 'application/pdf'
+    });
+    await s3Client.send(uploadCommand);
+    return `https://${bucket}.s3.amazonaws.com/${key}`;
+  } catch (error) {
+    console.error('Error uploading PDF:', error);
+    throw error;
+  }
+}

package/dist/server/users.js

@@ -0,0 +1,151 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUser = createUser;
+exports.deleteUser = deleteUser;
+exports.getUser = getUser;
+exports.getUserByEmail = getUserByEmail;
+exports.getUsersByIds = getUsersByIds;
+exports.updateUser = updateUser;
+var _libDynamodb = require("@aws-sdk/lib-dynamodb");
+var _dynamoDb = require("./dynamoDb.js");
+async function createUser(id, name, email, hashedPassword, otherData, tableName) {
+  if (!tableName) throw new Error('Table name is required');
+  try {
+    const item = {
+      user_id: id,
+      name,
+      email: email,
+      password: hashedPassword,
+      ...otherData,
+      createdAt: new Date().toISOString()
+    };
+    await _dynamoDb.dynamoDb.send(new _libDynamodb.PutCommand({
+      TableName: tableName,
+      Item: item
+    }));
+    return item;
+  } catch (error) {
+    console.error('Error in createUser:', error);
+    throw new Error('An error occurred while creating the user');
+  }
+}
+async function getUser(userId, tableName) {
+  try {
+    if (!tableName) throw new Error('Table name is required');
+    const result = await _dynamoDb.dynamoDb.send(new _libDynamodb.GetCommand({
+      TableName: tableName,
+      Key: {
+        user_id: userId
+      }
+    }));
+    return result.Item;
+  } catch (error) {
+    console.error('Error in getUser:', error);
+    throw new Error('An error occurred while retrieving the user');
+  }
+}
+async function updateUser(id, updates, tableName) {
+  if (!tableName) throw new Error('Table name is required');
+  try {
+    const updateExpressions = [];
+    const expressionAttributeValues = {};
+    const expressionAttributeNames = {};
+    Object.entries(updates).forEach(([key, value]) => {
+      updateExpressions.push(`#${key} = :${key}`);
+      expressionAttributeValues[`:${key}`] = value;
+      expressionAttributeNames[`#${key}`] = key;
+    });
+    const result = await _dynamoDb.dynamoDb.send(new _libDynamodb.UpdateCommand({
+      TableName: tableName,
+      Key: {
+        user_id: id
+      },
+      UpdateExpression: `SET ${updateExpressions.join(', ')}`,
+      ExpressionAttributeValues: expressionAttributeValues,
+      ExpressionAttributeNames: expressionAttributeNames,
+      ReturnValues: 'ALL_NEW'
+    }));
+    return result.Attributes;
+  } catch (error) {
+    console.error('Error in updateUser:', error);
+    throw new Error('An error occurred while updating the user');
+  }
+}
+async function deleteUser(id, tableName) {
+  try {
+    if (!tableName) throw new Error('Table name is required');
+    await _dynamoDb.dynamoDb.send(new _libDynamodb.DeleteCommand({
+      TableName: tableName,
+      Key: {
+        user_id: id
+      }
+    }));
+  } catch (error) {
+    console.error('Error in deleteUser:', error);
+    throw new Error('An error occurred while deleting the user');
+  }
+}
+async function getUserByEmail(email, tableName) {
+  try {
+    if (!tableName) throw new Error('Table name is required');
+    const result = await _dynamoDb.dynamoDb.send(new _libDynamodb.QueryCommand({
+      TableName: tableName,
+      IndexName: 'email-user_id-index',
+      KeyConditionExpression: 'email = :email',
+      ExpressionAttributeValues: {
+        ':email': email
+      },
+      Limit: 1
+    }));
+    return result.Items[0];
+  } catch (error) {
+    console.error('Error in getUserByEmail:', error);
+    throw new Error('An error occurred while retrieving the user');
+  }
+}
+async function getUsersByIds(userIds, tableName) {
+  try {
+    if (!tableName) throw new Error('Table name is required');
+    // If no userIds provided, return empty array
+    if (!userIds || userIds.length === 0) {
+      return [];
+    }
+
+    // DynamoDB only allows 25 items per BatchGetItem
+    const batchSize = 25;
+    let allUsers = [];
+
+    // Process users in batches
+    for (let i = 0; i < userIds.length; i += batchSize) {
+      const batch = userIds.slice(i, i + batchSize);
+      const result = await _dynamoDb.dynamoDb.send(new _libDynamodb.BatchGetCommand({
+        RequestItems: {
+          [tableName]: {
+            Keys: batch.map(id => ({
+              user_id: id
+            }))
+          }
+        }
+      }));
+      if (result.Responses && result.Responses[tableName]) {
+        // Remove sensitive data from users
+        const safeUsers = result.Responses[tableName].map(user => {
+          const {
+            password,
+            ...safeUser
+          } = user;
+          return safeUser;
+        });
+        allUsers = [...allUsers, ...safeUsers];
+      }
+    }
+    return allUsers;
+  } catch (error) {
+    console.error('Error in getUsersByIds:', error);
+    throw new Error('An error occurred while retrieving the users');
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "@gonextgames/utils",
+    "exports": {
+        "./client": "./dist/client/index.js",
+        "./client/*": "./dist/client/*.js",
+        "./server": "./dist/server/index.js",
+        "./server/*": "./dist/server/*.js",
+        "./client/auth": "./dist/client/auth/index.jsx",
+        "./server/auth": "./dist/server/auth/index.js"
+    },
+    "version": "0.0.15",
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/",
+        "access": "public"
+    },
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "babel src -d dist --copy-files",
+        "prepare": "npm run build",
+        "dev": "babel src -d dist --copy-files --watch"
+    },
+    "dependencies": {
+        "@aws-sdk/client-dynamodb": "^3.726.1",
+        "@aws-sdk/lib-dynamodb": "^3.726.1",
+        "@aws-sdk/client-s3": "^3.726.1",
+        "axios": "^1.7.9",
+        "bcryptjs": "^2.4.3",
+        "jsonwebtoken": "^9.0.0",
+        "nodemailer": "^6.9.16",
+        "openai": "^4.0.0",
+        "next": "^15.1.4",
+        "next-sitemap": "^4.2.3",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0",
+        "zustand": "^5.0.3"
+    },
+    "devDependencies": {
+        "@babel/cli": "^7.23.9",
+        "@babel/core": "^7.23.9",
+        "@babel/preset-env": "^7.23.9",
+        "@babel/preset-react": "^7.23.9",
+        "next": "^15.1.4"
+    },
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "peerDependencies": {
+        "next": "15.1.4"
+    }
+}

package/readme.md

@@ -0,0 +1,129 @@
+# Go Next Games Landing Utils
+
+This is a collection of utilities for the Go Next Games Landing Page.
+
+## Development
+
+In your package.json, add the following:
+```json
+"@gonextgames/utils-client": "file:/Users/oliverbarnum/Documents/git/utils/client",
+"@gonextgames/utils-server": "file:/Users/oliverbarnum/Documents/git/utils/server",
+```
+
+Then run `npm install`
+
+Create an .env file:
+
+```json
+AWS_ACCESS_KEY=""
+AWS_SECRET=""
+ENVIRONMENT=""
+JWT_SECRET_KEY=""
+STRIPE_API=""
+STRIPE_PUBLIC_KEY=""
+OPENAI_API_KEY=""
+```
+Then
+```
+cd ./client
+npm run dev
+```
+New Terminal:
+```
+cd ./server
+npm run dev
+```
+
+## Auth
+
+### Client Side Consumption
+
+- Wrap the layout in `<AuthProvider></AuthProvider>`
+- In components that need to know whether you are auth'd:
+
+```js
+import { useAuth, trackEvent } from '@gonextgames/utils-client'
+const { isAuthenticated, logout, user } = useAuth()
+```
+- To change auth
+```js
+import { useAuth } from '@gonextgames/utils-client'
+// Call these functions to call the backend
+const { login/register/logout } = useAuth()
+```
+When implementing auth, you can use the `redirect` function with the `from` parameter to redirect after logging in. After registering, you can redirect to the getting started page or whatever is appropriate for your application.
+
+### Server Side Consumption
+
+- Implement /api/auth/verify for tokens
+
+```js
+import { getUserFromToken } from '@gonextgames/utils-server'
+
+export async function GET(req) {
+  try {
+    const user = await getUserFromToken("NAME_OF_USERS_TABLE", "TOKEN_NAME")
+    if (user === null) {
+      return Response.json({authenticated: false}, { status: 200 })
+    }
+    return Response.json({authenticated: true, user: user})
+  } catch (error) {
+    console.error('Verify token error:', error)
+    return Response.json({ authenticated: false, error: 'Token verification failed' }, { status: 401 })
+  }
+} 
+```
+
+- Consume it with
+
+```js
+import { getUserFromToken } from '@gonextgames/utils-server'
+const user = await getUserFromToken("NAME_OF_USERS_TABLE", "TOKEN_NAME")
+  if (!user) {
+    redirect(`/login?from=${encodeURIComponent('/FROM-ENDPOINT')}`)
+  }
+```
+
+- Create /api/auth/login /logout and /register
+
+```js
+// Register
+const user = await registerUser(userData.name, userData.email, userData.password, { link: userData.link }, 'bgp_users')
+
+// Login
+const user = await loginWithEmailAndPasswordAndSetToken(email, password, 'bgp_users', "token")
+
+//Logout 
+const cookieStore = await cookies()
+
+cookieStore.set('token', '', {
+httpOnly: true,
+secure: process.env.ENVIRONMENT === 'production',
+sameSite: 'lax',
+path: '/',
+expires: new Date(0)
+})
+```
+
+### Users Table
+
+The user table is standardized. Calling CRUD for users is handled by the package, where you pass the `TABLE_NAME` to the function every time you want to call it. 
+
+```js
+await updateUser(user.user_id, {
+    contact_email: email,
+}, 'bgp_users')
+```
+
+Nothing is stopping you from creating new ways to get the information, such as by the users /link, like in Board Game Prototypes.
+
+The users table must have:
+
+- user_id
+- email
+- name
+- password
+
+And a `email-user_id-index` secondary index.
+
+## Event Tracking