nitro-web 0.0.167 → 0.0.169

package/client/app.tsx

@@ -19,7 +19,7 @@ type Settings = {
   // beforeStoreUpdate: (prevStore: Store | null, newData: Store) => Store
   isStatic?: boolean
   layouts: React.FC<LayoutProps>[]
-  middleware: Record<string, (route: unknown, store: Store) => undefined | { redirect: string }>
+  allMiddleware: Record<string, (route: unknown, store: Store) => undefined | { redirect: string }>
   name: string
   titleSeparator?: string
 }
@@ -52,7 +52,7 @@ export async function setupApp(config: Config, storeContainer: StoreContainer, l
     beforeApp: config.beforeApp || beforeApp,
     isStatic: config.isStatic,
     layouts: layouts,
-    middleware: Object.assign(defaultMiddleware, config.middleware || {}),
+    allMiddleware: Object.assign(middleware, config.middleware || {}),
     name: config.name,
     titleSeparator: config.titleSeparator,
   }
@@ -165,9 +165,9 @@ function getRouter({ settings, config }: { settings: Settings, config: Config })
           const layoutNum = (parseInt(String(route.meta?.layout || '1')) || 1) - 1
 
           // get the routes middleware
-          const middleware = toArray(route[routePath]).filter((policyNameOrTrue) => {
+          const routeMiddleware = toArray(route[routePath]).filter((policyNameOrTrue) => {
             if (policyNameOrTrue === true) return // ignore true
-            else if (policyNameOrTrue in settings.middleware) return true
+            else if (policyNameOrTrue in settings.allMiddleware) return true
             else console.error(`No middleware named '${policyNameOrTrue}' defined under config.middleware, skipping..`)
           })
 
@@ -180,7 +180,7 @@ function getRouter({ settings, config }: { settings: Settings, config: Config })
               layout: layoutNum,
               title: `${route.meta?.title ? `${route.meta.title}${settings.titleSeparator || ' - '}` : ''}${settings.name}`,
             },
-            middleware: middleware as string[],
+            middleware: routeMiddleware as string[],
             name: componentName,
             path: routePath,
             redirect: route.redirect,
@@ -218,7 +218,7 @@ function getRouter({ settings, config }: { settings: Settings, config: Config })
               await setTimeoutPromise(() => {}, 0)
             }
             for (const key of route.middleware) {
-              const error = settings.middleware[key](route, exposedStoreData || {})
+              const error = settings.allMiddleware[key](route, exposedStoreData || {})
               // Note: the redirect uses the new pathname for query string values, e.g. '?example=value'. We also can't use the 
               // current pathname, as this doesn't exist on page refresh.
               if (error && error.redirect) {
@@ -317,22 +317,19 @@ async function beforeApp(config: Config) {
   return { ...storeData, apiAvailable }
 }
 
-const defaultMiddleware = {
-  // Global middleware that can referenced from component routes
+export const middleware = {
+  // Default middleware that can referenced from component routes
   isAdmin: (route: unknown, store: { user?: { type?: string, isAdmin?: boolean } }) => {
-    const user = store.user || { type: 'visitor' }
-    if (user?.type?.match(/admin/) || user?.isAdmin) return
-    else if (user?.type && user?.type !== 'visitor') return { redirect: '/signin?unauth' }
+    if (store.user?.type?.match(/admin/) || store.user?.isAdmin) return
+    else if (store.user) return { redirect: '/signin?unauth' }
     else return { redirect: '/signin?signin' }
   },
   isSubscribed: (route: unknown, store: { user?: { company?: { currentSubscription?: string } } }) => {
-    const user = store?.user || { type: 'visitor', company: { currentSubscription: '' } }
-    if (!user?.company?.currentSubscription) return
+    if (store.user?.company?.currentSubscription) return
     else return { redirect: '/plans/subscribe' }
   },
   isUser: (route: unknown, store: { user?: { type?: string } }) => {
-    const user = store.user || { type: 'visitor' }
-    if (user?.type !== 'visitor') return
+    if (store.user) return
     else return { redirect: '/signin?signin' }
   },
 }

package/client/index.ts

@@ -9,7 +9,7 @@ export * as util from 'nitro-web/util'
 export * from '../types'
 
 // Main app functions
-export { setupApp, updateJwt } from './app'
+export { setupApp, updateJwt, middleware } from './app'
 export { createStore, exposedStoreData, preloadedStoreData, setStoreWrapper } from './store'
 
 // Component Pages

package/components/auth/auth.api.js

@@ -19,11 +19,17 @@ export const routes = {
   'post    /api/signin': [signin],
   'post    /api/signup': [signup],
   'post    /api/reset-instructions': [resetInstructions],
-  'post    /api/reset-password': [resetPassword],
+  'post    /api/reset-password': [resetConfirm],
   'post    /api/invite-instructions': [inviteInstructions],
-  'post    /api/invite-accept': [resetPassword],
+  'post    /api/invite-accept': [inviteConfirm],
   'delete  /api/account/:uid': [remove],
 
+  // todo: 
+  //   We dont need all of these overridable, just signinAndGetStore, findUserFromProvider, 
+  //   and getStore. So we will allow just these two to be passed around.
+  //   userCreate not needed, they can just create their own signup function.
+  ///  Maybe we can pass these into setup?
+
   // Overridable helpers
   setup: setup,
   findUserFromProvider: findUserFromProvider,
@@ -33,14 +39,16 @@ export const routes = {
   tokenParse: tokenParse,
   userCreate: userCreate,
   validatePassword: validatePassword,
+  sendToken: sendToken,
+  inviteOrResetConfirm: inviteOrResetConfirm,
 }
 
 function setup(middleware, _config) {
   // routes.setup is called automatically when express starts
   // Set config values
-  const configKeys = ['clientUrl', 'emailFrom', 'env', 'name', 'mailgunDomain', 'mailgunKey', 'masterPassword', 'isNotMultiTenant']
+  const configKeys = ['baseUrl', 'emailFrom', 'env', 'name', 'mailgunDomain', 'mailgunKey', 'masterPassword', 'isNotMultiTenant']
   authConfig = pick(_config, configKeys)
-  for (const key of ['clientUrl', 'emailFrom', 'env', 'name']) {
+  for (const key of ['baseUrl', 'emailFrom', 'env', 'name']) {
     if (!authConfig[key]) throw new Error(`Missing config value for: config.${key}`)
   }
 
@@ -140,95 +148,6 @@ function signout(req, res) {
   res.json('{}')
 }
 
-async function resetInstructions(req, res) {
-  try {
-    let email = (req.body.email || '').trim().toLowerCase()
-    if (!email) throw { title: 'email', detail: 'The email you entered is incorrect.' }
-
-    let user = await db.user.findOne({ query: { email }, _privateData: true })
-    if (!user) throw { title: 'email', detail: 'The email you entered is incorrect.' }
-
-    let resetToken = await tokenCreate(user._id)
-    await db.user.update({ query: { email }, $set: { resetToken }})
-
-    res.json({})
-    sendEmail({
-      config: authConfig,
-      template: 'reset-password',
-      to: `${ucFirst(user.firstName)}<${email}>`,
-      data: {
-        token: resetToken + (req.query.hasOwnProperty('desktop') ? '?desktop' : ''),
-      },
-    }).catch(err => console.error('sendEmail(..) mailgun error', err))
-  } catch (err) {
-    res.error(err)
-  }
-}
-
-async function resetPassword(req, res) {
-  try {
-    const { token, password, password2 } = req.body
-    const name = req.path.includes('invite') ? 'inviteToken' : 'resetToken'
-    const desktop = req.query.desktop
-    const id = tokenParse(token)
-    await validatePassword(password, password2)
-
-    let user = await db.user.findOne({ query: id, blacklist: ['-' + name], _privateData: true })
-    if (!user || user[name] !== token) throw new Error('Sorry your token is invalid or has already been used.')
-
-    await db.user.update({
-      query: user._id,
-      data: {
-        password: await bcrypt.hash(password, 10),
-        resetToken: '',
-      },
-      blacklist: ['-' + name, '-password'],
-    })
-    res.send(await this.signinAndGetStore({ ...user, [name]: undefined }, desktop, this.getStore))
-  } catch (err) {
-    res.error(err)
-  }
-}
-
-async function inviteInstructions(req, res) {
-  try {
-    // Check if user is admin here rather than in middleware (which may not exist yet)
-    if (req.user.type != 'admin' && !req.user.isAdmin) {
-      throw new Error('You are not authorized to invite users.')
-    }
-    const inviteToken = await tokenCreate()
-    const userData = await db.user.validate({
-      ...pick(req.body, ['email', 'firstName', 'lastName']),
-      status: 'invited',
-      inviteToken: inviteToken,
-    })
-
-    // Check if user already exists
-    if (await db.user.findOne({ query: { email: userData.email } })) {
-      throw { title: 'email', detail: 'User already exists.' }
-    }
-
-    // Create user
-    const user = await db.user.insert({
-      data: userData,
-    })
-
-    // Send email
-    res.send(user)
-    sendEmail({
-      config: authConfig,
-      template: 'invite-user',
-      to: `${ucFirst(userData.firstName)}<${userData.email}>`,
-      data: {
-        token: inviteToken + (req.query.hasOwnProperty('desktop') ? '?desktop' : ''),
-      },
-    }).catch(err => console.error('sendEmail(..) mailgun error', err))
-
-  } catch (err) {
-    return res.error(err)
-  }
-}
-
 async function remove(req, res) {
   try {
     const uid = db.id(req.params.uid || 'badid')
@@ -409,4 +328,124 @@ export async function validatePassword(password='', password2) {
   } else if (typeof password2 != 'undefined' && password !== password2) {
     throw [{ title: 'password2', detail: 'Your passwords need to match.' }]
   }
+}
+
+
+
+
+/* ---- Controllers -------------------------- */
+
+export async function resetInstructions(req, res) {
+  try {
+    // const desktop = req.query.hasOwnProperty('desktop') ? '?desktop' : '' // see sendToken for future usage
+    let email = (req.body.email || '').trim().toLowerCase()
+    if (!email) throw { title: 'email', detail: 'The email you entered is incorrect.' }
+
+    let user = await db.user.findOne({ query: { email }, _privateData: true })
+    if (!user) throw { title: 'email', detail: 'The email you entered is incorrect.' }
+
+    // Send reset password email
+    await sendToken({ type: 'reset', user: user })
+    res.json({})
+  } catch (err) {
+    res.error(err)
+  }
+}
+
+export async function inviteInstructions(req, res) {
+  try {
+    // const desktop = req.query.hasOwnProperty('desktop') ? '?desktop' : '' // see sendToken for future usage
+    let user = await db.user.findOne({ query: { _id: req.params._id }, _privateData: true })
+    if (!user) throw new Error('Invalid user id')
+    // Send invite instructions email
+    await sendToken({ type: 'invite', user: user })
+    res.json({})
+  } catch (err) {
+    res.error(err)
+  }
+}
+
+export async function inviteConfirm(req, res) {
+  try {
+    res.send(await this.inviteOrResetConfirm('invite', req))
+  } catch (err) {
+    res.error(err)
+  }
+}
+
+export async function resetConfirm(req, res) {
+  try {
+    res.send(await this.inviteOrResetConfirm('reset', req))
+  } catch (err) {
+    res.error(err)
+  }
+}
+
+/* ---- Helpers ------------------------------ */
+
+export async function inviteOrResetConfirm(type, req) {
+  const { token, password, password2 } = req.body
+  const name = type === 'invite' ? 'inviteToken' : 'resetToken'
+  const desktop = req.query.desktop
+  const id = tokenParse(token)
+  await validatePassword(password, password2)
+
+  let user = await db.user.findOne({ query: id, blacklist: ['-' + name], _privateData: true })
+  if (!user || user[name] !== token) throw new Error('Sorry your token is invalid or has already been used.')
+
+  await db.user.update({
+    query: user._id,
+    data: {
+      password: await bcrypt.hash(password, 10),
+      [name]: '', // remove token
+    },
+    blacklist: ['-' + name, '-password'],
+  })
+  const store = await this.signinAndGetStore({ ...user, [name]: undefined }, desktop, this.getStore)
+  return store
+}
+
+/**
+ * Checks if the user exists, updates the user with the invite token and sends the invite email
+ * @param {object} options
+ * @param {'reset' | 'invite'} options.type -  The type of token to send (default: 'reset')
+ * @param {{_id: string, email: string, firstName: string}} options.user -  The user to send the invite email to
+ * @param {function} [options.beforeUpdate] - callback hook to run before updating the user
+ * @param {function} [options.beforeSendEmail] -  callback hook to run before sending the email
+ * @returns {Promise<{token: string, mailgunPromise: Promise<unknown>}>}
+ */
+export async function sendToken({ type = 'reset', user, beforeUpdate, beforeSendEmail }) {
+  if (!user?._id) throw new Error('user is required')
+  if (!user?.email) throw new Error('user.email is required')
+  if (!user?.firstName) throw new Error('user.firstName is required')
+  const token = await tokenCreate(user._id)
+
+  // get the data
+  const data = beforeUpdate ? beforeUpdate({ [type + 'Token']: token }) : { [type + 'Token']: token }
+  if (type === 'invite') data.isInvited = true
+
+  // Update the user with the token
+  const result = await db.user.update({
+    query: { _id: user._id },
+    data: data,
+    blacklist: ['-' + type + 'Token'],
+  })
+
+  if (!result._output.matchedCount) {
+    throw new Error('Invalid user id to send the token to')
+  }
+
+  // Send email
+  const options = {
+    config: authConfig,
+    template: type === 'reset' ? 'reset-password' : 'invite-user',
+    to: `${ucFirst(user.firstName)}<${user.email}>`,
+    data: { token: token }, // + (req.query.hasOwnProperty('desktop') ? '?desktop' : '')
+  }
+  const mailgunPromise = sendEmail(beforeSendEmail ? beforeSendEmail(options, token) : options).catch(err => {
+    console.error('sendEmail(..) mailgun error', err)
+  })
+
+  // Return the token and mailgun promise
+  return { token, mailgunPromise }
 }

package/components/auth/reset.tsx

@@ -69,7 +69,7 @@ export function ResetPassword({ className, elements, redirectTo }: resetInstruct
     try {
       const data = await request('post /api/reset-password', state, event, isLoading, setState)
       setStore((s) => ({ ...s, ...data }))
-      navigate(redirectTo || '/')
+      setTimeout(() => navigate(redirectTo || '/'), 10) // wait for setStore
     } catch (e) {
       return setState({ ...state, errors: e as Errors })
     }

package/components/auth/signin.tsx

@@ -51,7 +51,7 @@ export function Signin({ className, elements, redirectTo }: signinProps) {
       setTimeout(() => { // wait for setStore
         if (location.search.includes('redirect')) navigate(location.search.replace('?redirect=', ''))
         else navigate(redirectTo || '/')
-      }, 100) 
+      }, 10) 
     } catch (e) {
       return setState({ ...state, errors: e as Errors})
     }

package/components/auth/signup.tsx

@@ -28,7 +28,7 @@ export function Signup({ className, elements, redirectTo }: signupProps) {
     try {
       const data = await request('post /api/signup', state, e, isLoading, setState)
       setStore((prev) => ({ ...prev, ...data }))
-      setTimeout(() => navigate(redirectTo || '/'), 0) // wait for setStore
+      setTimeout(() => navigate(redirectTo || '/'), 10) // wait for setStore
     } catch (e) {
       setState((prev) => ({ ...prev, errors: e as Errors }))
     }

package/components/billing/stripe.api.js

@@ -21,7 +21,7 @@ function setup(middleware, _config) {
   // Set config values
   config = {
     env: _config.env,
-    clientUrl: _config.clientUrl,
+    baseUrl: _config.baseUrl,
     stripeSecretKey: _config.stripeSecretKey,
     stripeWebhookSecret: _config.stripeWebhookSecret,
   }
@@ -81,7 +81,7 @@ async function billingPortalSessionCreate(req, res) {
     }
     const session = await stripe.billingPortal.sessions.create({
       customer: req.user.stripeCustomer.id,
-      return_url: config.clientUrl + '/subscriptions',
+      return_url: config.baseUrl + '/subscriptions',
     })
     res.json(session.url)
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-web",
-  "version": "0.0.167",
+  "version": "0.0.169",
   "repository": "github:boycce/nitro-web",
   "homepage": "https://boycce.github.io/nitro-web/",
   "description": "Nitro is a battle-tested, modular base project to turbocharge your projects, styled using Tailwind 🚀",

package/server/email/index.js

@@ -15,7 +15,7 @@ const _dirname = dirname(fileURLToPath(import.meta.url)) + '/'
 
 /**
  * Sends an email using a predefined template, with optional data/or recipientVariables
- * @typedef {{ clientUrl?: string, emailFrom?: string, mailgunDomain?: string, mailgunKey?: string, name?: string }} Config
+ * @typedef {{ baseUrl?: string, emailFrom?: string, mailgunDomain?: string, mailgunKey?: string, name?: string }} Config
  *
  * @param {object} opts
  * @param {string} opts.template - Template name or raw HTML, e.g., 'reset-password'
@@ -46,8 +46,8 @@ export async function sendEmail({
 }) {
   if (!config) {
     throw new Error('sendEmail: `config` missing')
-  } else if (!config.clientUrl) {
-    throw new Error('sendEmail: `config.clientUrl` is missing')
+  } else if (!config.baseUrl) {
+    throw new Error('sendEmail: `config.baseUrl` is missing')
   } else if (!config.emailFrom) {
     throw new Error('sendEmail: `config.emailFrom` is missing')
   } else if (!test && (!config.mailgunKey || !config.mailgunDomain)) {
@@ -81,7 +81,7 @@ export async function sendEmail({
     recipientVariables[toEmail] = {
       ...(data || {}),
       configName: ucFirst(config.name),
-      domain: config.clientUrl,
+      domain: config.baseUrl,
       replyToEmail: getNameEmail(replyTo)[1],
       replyToName: getNameEmail(replyTo)[0],
       email: toEmail,
@@ -95,7 +95,7 @@ export async function sendEmail({
     bcc: bcc,
     emailTemplateDir: getDirectories(path, config.pwd).emailTemplateDir,
     from: from,
-    isDev: config.clientUrl.match(/:/), // possibly use config.env here
+    isDev: config.baseUrl.match(/:/), // possibly use config.env here
     recipientVariables: recipientVariables,
     replyTo: replyTo,
     skipCssInline: skipCssInline,
@@ -103,7 +103,7 @@ export async function sendEmail({
     template: template,
     test: config.emailTestMode || test,
     to: to,
-    url: config.clientUrl,
+    url: config.baseUrl,
   }
 
   // Grab html and send

package/server/email/invite-user.html

@@ -1,3 +1,11 @@
+
+<!--
+todo: change naming to:
+  invite-link
+  invite-confirm
+  reset-link
+  reset-confirm
+-->
 <!-- extends references the default nitro layout file -->
 {% extends "partials/layout1.swig" %}
 

package/server/models/user.js

@@ -7,20 +7,23 @@ export default {
     avatar: { type: 'image' },
     company: { model: 'company', required: true },
     email: { type: 'email', required: true, index: 'unique' },
+    isInvited: { type: 'boolean' },
     firstName: { type: 'string', required: true },
     lastName: { type: 'string', required: true },
-    password: { type: 'string', minLength: 6 },
-    resetToken: { type: 'string' },
     status: { type: 'string', default: 'active', enum: ['active', 'deleted', 'inactive'] },
     stripeCustomer: { type: 'any' },
     stripeSubscription: { type: 'any' },
     stripeIntents: { type: 'any' },
     type: { type: 'string', default: 'user', enum: ['user', 'admin'] },
     usedFreeTrial: { type: 'boolean', default: false },
+    // hidden fields
+    password: { type: 'string', minLength: 6 },
+    inviteToken: { type: 'string' },
+    resetToken: { type: 'string' },
   },
 
-  findBL: ['password', 'resetToken'],
-  updateBL: ['company', 'password', 'resetToken', 'status', 'stripeSubscription', 'type', 'usedFreeTrial'],
+  findBL: ['password', 'inviteToken', 'resetToken'],
+  updateBL: ['password', 'inviteToken', 'resetToken', 'company', 'status', 'stripeSubscription', 'type', 'usedFreeTrial'],
 
   messages: {
     lastName: {

package/server/router.js

@@ -1,4 +1,5 @@
 // @ts-nocheck
+// renamed to app, similar to client/app.tsx
 import fs from 'fs'
 import path, { dirname } from 'path'
 import http from 'http'

package/types/components/auth/auth.api.d.ts

@@ -11,15 +11,42 @@ export function userCreate({ business, password, ...userDataProp }: {
 export function tokenCreate(id: any): Promise<any>;
 export function tokenParse(token: any): any;
 export function validatePassword(password: string, password2: any): Promise<void>;
+export function resetInstructions(req: any, res: any): Promise<void>;
+export function inviteInstructions(req: any, res: any): Promise<void>;
+export function inviteConfirm(req: any, res: any): Promise<void>;
+export function resetConfirm(req: any, res: any): Promise<void>;
+export function inviteOrResetConfirm(type: any, req: any): Promise<any>;
+/**
+ * Checks if the user exists, updates the user with the invite token and sends the invite email
+ * @param {object} options
+ * @param {'reset' | 'invite'} options.type -  The type of token to send (default: 'reset')
+ * @param {{_id: string, email: string, firstName: string}} options.user -  The user to send the invite email to
+ * @param {function} [options.beforeUpdate] - callback hook to run before updating the user
+ * @param {function} [options.beforeSendEmail] -  callback hook to run before sending the email
+ * @returns {Promise<{token: string, mailgunPromise: Promise<unknown>}>}
+ */
+export function sendToken({ type, user, beforeUpdate, beforeSendEmail }: {
+    type: "reset" | "invite";
+    user: {
+        _id: string;
+        email: string;
+        firstName: string;
+    };
+    beforeUpdate?: Function;
+    beforeSendEmail?: Function;
+}): Promise<{
+    token: string;
+    mailgunPromise: Promise<unknown>;
+}>;
 export const routes: {
     'get     /api/store': (typeof store)[];
     'get     /api/signout': (typeof signout)[];
     'post    /api/signin': (typeof signin)[];
     'post    /api/signup': (typeof signup)[];
     'post    /api/reset-instructions': (typeof resetInstructions)[];
-    'post    /api/reset-password': (typeof resetPassword)[];
+    'post    /api/reset-password': (typeof resetConfirm)[];
     'post    /api/invite-instructions': (typeof inviteInstructions)[];
-    'post    /api/invite-accept': (typeof resetPassword)[];
+    'post    /api/invite-accept': (typeof inviteConfirm)[];
     'delete  /api/account/:uid': (typeof remove)[];
     setup: typeof setup;
     findUserFromProvider: typeof findUserFromProvider;
@@ -29,14 +56,13 @@ export const routes: {
     tokenParse: typeof tokenParse;
     userCreate: typeof userCreate;
     validatePassword: typeof validatePassword;
+    sendToken: typeof sendToken;
+    inviteOrResetConfirm: typeof inviteOrResetConfirm;
 };
 declare function store(req: any, res: any): Promise<void>;
 declare function signout(req: any, res: any): void;
 declare function signin(req: any, res: any): any;
 declare function signup(req: any, res: any): Promise<void>;
-declare function resetInstructions(req: any, res: any): Promise<void>;
-declare function resetPassword(req: any, res: any): Promise<void>;
-declare function inviteInstructions(req: any, res: any): Promise<any>;
 declare function remove(req: any, res: any): Promise<void>;
 declare function setup(middleware: any, _config: any): void;
 export {};

package/types/components/auth/auth.api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.api.d.ts","sourceRoot":"","sources":["../../../components/auth/auth.api.js"],"names":[],"mappings":"AAmQA,qGAyCC;AAED;;GAKC;AAED,0FAQC;AAED;;;;iBAkDC;AAED,mDAOC;AAED,4CAYC;AAED,kFAiBC;AA7YD;;;;;;;;;;;;;;;;;;EAqBC;AAmED,0DAEC;AAkCD,mDAEC;AAnBD,iDAeC;AA9BD,2DAaC;AAuBD,sEAuBC;AAED,kEAuBC;AAED,sEAqCC;AAED,2DAwBC;AA1ND,4DA+DC"}
+{"version":3,"file":"auth.api.d.ts","sourceRoot":"","sources":["../../../components/auth/auth.api.js"],"names":[],"mappings":"AAkLA,qGAyCC;AAED;;GAKC;AAED,0FAQC;AAED;;;;iBAkDC;AAED,mDAOC;AAED,4CAYC;AAED,kFAiBC;AAOD,qEAeC;AAED,sEAWC;AAED,iEAMC;AAED,gEAMC;AAID,wEAoBC;AAED;;;;;;;;GAQG;AACH,yEANG;IAAoC,IAAI,EAAhC,OAAO,GAAG,QAAQ;IACuC,IAAI,EAA7D;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC;IAC5B,YAAY;IACZ,eAAe;CAC1C,GAAU,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAC,CAAC,CAoCtE;AApbD;;;;;;;;;;;;;;;;;;;;EA6BC;AAmED,0DAEC;AAkCD,mDAEC;AAnBD,iDAeC;AA9BD,2DAaC;AAuBD,2DAwBC;AAjID,4DA+DC"}

package/types/server/email/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Sends an email using a predefined template, with optional data/or recipientVariables
- * @typedef {{ clientUrl?: string, emailFrom?: string, mailgunDomain?: string, mailgunKey?: string, name?: string }} Config
+ * @typedef {{ baseUrl?: string, emailFrom?: string, mailgunDomain?: string, mailgunKey?: string, name?: string }} Config
  *
  * @param {object} opts
  * @param {string} opts.template - Template name or raw HTML, e.g., 'reset-password'
@@ -33,7 +33,7 @@ export function sendEmail({ template, to, config, bcc, data, from, replyTo, reci
  * Sends an email using a predefined template, with optional data/or recipientVariables
  */
 export type Config = {
-    clientUrl?: string;
+    baseUrl?: string;
     emailFrom?: string;
     mailgunDomain?: string;
     mailgunKey?: string;

package/types/server/email/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/email/index.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;GAiBG;AACH,iIAbG;IAAqB,QAAQ,EAArB,MAAM;IACO,EAAE,EAAf,MAAM;IACO,MAAM,EAAnB,MAAM;IACQ,GAAG,GAAjB,MAAM;IACQ,IAAI,GAAlB,MAAM;IACQ,IAAI,GAAlB,MAAM;IACQ,OAAO,GAArB,MAAM;IACQ,kBAAkB,GAAhC,MAAM;IACQ,OAAO,GAArB,MAAM;IACS,aAAa,GAA5B,OAAO;IACQ,IAAI,GAAnB,OAAO;CACf,GAAU,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAiF/B;;;;qBA/FY;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/email/index.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;GAiBG;AACH,iIAbG;IAAqB,QAAQ,EAArB,MAAM;IACO,EAAE,EAAf,MAAM;IACO,MAAM,EAAnB,MAAM;IACQ,GAAG,GAAjB,MAAM;IACQ,IAAI,GAAlB,MAAM;IACQ,IAAI,GAAlB,MAAM;IACQ,OAAO,GAArB,MAAM;IACQ,kBAAkB,GAAhC,MAAM;IACQ,OAAO,GAArB,MAAM;IACS,aAAa,GAA5B,OAAO;IACQ,IAAI,GAAnB,OAAO;CACf,GAAU,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAiF/B;;;;qBA/FY;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE"}

package/types/server/models/user.d.ts

@@ -14,62 +14,70 @@ declare namespace _default {
             export { required_1 as required };
             export let index: string;
         }
-        export namespace firstName {
+        export namespace isInvited {
             let type_2: string;
             export { type_2 as type };
-            let required_2: boolean;
-            export { required_2 as required };
         }
-        export namespace lastName {
+        export namespace firstName {
             let type_3: string;
             export { type_3 as type };
-            let required_3: boolean;
-            export { required_3 as required };
+            let required_2: boolean;
+            export { required_2 as required };
         }
-        export namespace password {
+        export namespace lastName {
             let type_4: string;
             export { type_4 as type };
-            export let minLength: number;
+            let required_3: boolean;
+            export { required_3 as required };
         }
-        export namespace resetToken {
+        export namespace status {
             let type_5: string;
             export { type_5 as type };
-        }
-        export namespace status {
-            let type_6: string;
-            export { type_6 as type };
             let _default: string;
             export { _default as default };
             let _enum: string[];
             export { _enum as enum };
         }
         export namespace stripeCustomer {
+            let type_6: string;
+            export { type_6 as type };
+        }
+        export namespace stripeSubscription {
             let type_7: string;
             export { type_7 as type };
         }
-        export namespace stripeSubscription {
+        export namespace stripeIntents {
             let type_8: string;
             export { type_8 as type };
         }
-        export namespace stripeIntents {
-            let type_9: string;
-            export { type_9 as type };
-        }
-        export namespace type_10 {
-            let type_11: string;
-            export { type_11 as type };
+        export namespace type_9 {
+            let type_10: string;
+            export { type_10 as type };
             let _default_1: string;
             export { _default_1 as default };
             let _enum_1: string[];
             export { _enum_1 as enum };
         }
-        export { type_10 as type };
+        export { type_9 as type };
         export namespace usedFreeTrial {
-            let type_12: string;
-            export { type_12 as type };
+            let type_11: string;
+            export { type_11 as type };
             let _default_2: boolean;
             export { _default_2 as default };
         }
+        export namespace password {
+            let type_12: string;
+            export { type_12 as type };
+            export let minLength: number;
+        }
+        export namespace inviteToken {
+            let type_13: string;
+            export { type_13 as type };
+        }
+        export namespace resetToken {
+            let type_14: string;
+            export { type_14 as type };
+        }
     }
     let findBL: string[];
     let updateBL: string[];

package/types/server/models/user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../server/models/user.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8CmB,gCAEd"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../server/models/user.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiDmB,gCAEd"}

package/types/server/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../server/router.js"],"names":[],"mappings":"AAmCA,wHA6HC;AAoPD,+CAEC;AAED,kEAYC;AApGD,+BAA+B;AAC/B,yBADW,gBAAgB,CAkF1B;sBAnYY,OAAO,CAAC,OAAO,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAoB,CAAC;CAC7B;uBACS,OAAO,CAAC,QAAQ,GAAG;IAC3B,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjE,YAAY,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;IACvD,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;IACpD,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;IACnD,WAAW,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;CACvD;+BACS;IACR,KAAK,EAAE,MAAM,EAAE,CAAC;IACpB,CAAK,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,UAAU,KAAK,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC;CACnF;iBA1Ba,MAAM;oBAIH,SAAS"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../server/router.js"],"names":[],"mappings":"AAoCA,wHA6HC;AAoPD,+CAEC;AAED,kEAYC;AApGD,+BAA+B;AAC/B,yBADW,gBAAgB,CAkF1B;sBAnYY,OAAO,CAAC,OAAO,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAoB,CAAC;CAC7B;uBACS,OAAO,CAAC,QAAQ,GAAG;IAC3B,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjE,YAAY,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;IACvD,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;IACpD,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;IACnD,WAAW,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC;CACvD;+BACS;IACR,KAAK,EAAE,MAAM,EAAE,CAAC;IACpB,CAAK,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,UAAU,KAAK,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC;CACnF;iBA1Ba,MAAM;oBAIH,SAAS"}

package/types.ts

@@ -2,7 +2,7 @@
 
 type InjectedConfig = {
   awsUrl?: string
-  clientUrl: string
+  baseUrl: string
   env: string
   googleMapsApiKey?: string
   isDemo: boolean // implicitly defined by webpack
@@ -29,6 +29,7 @@ export type User = {
   name?: string
   avatar?: MonasteryImage
   isAdmin?: boolean
+  isInvited?: boolean
   type?: string
 }
 

package/util.js

@@ -103,9 +103,9 @@ export function axios ({ createConfig } = {}) {
   if (typeof window !== 'undefined') {
     if (!axiosNonce) {
       // Remove mobile specific protocol and subdomain
-      const clientOrigin = window.document.location.origin.replace(/^(capacitor|https):\/\/(mobile\.)?/, 'https://')
+      const baseUrl = window.document.location.origin.replace(/^(capacitor|https):\/\/(mobile\.)?/, 'https://')
       axiosNonce = true
-      _axios.defaults.baseURL = clientOrigin
+      _axios.defaults.baseURL = baseUrl
       _axios.defaults.headers.desktop = true
       _axios.defaults.withCredentials = true
       _axios.defaults.timeout = 60000