@wasp.sh/wasp-cli-darwin-x64-unknown 0.25.0 → 0.26.0

package/data/Generator/templates/sdk/wasp/auth/forms/internal/email/VerifyEmailForm.tsx

@@ -1,8 +1,7 @@
-import { useLocation } from 'react-router'
 import { useAuthContext } from '@wasp.sh/lib-auth/browser'
+import { useLocation } from 'react-router'
 import { verifyEmail } from '../../../email/actions/verifyEmail.js'
-import { Message } from '../Message'
-import { useEffectOnce } from '../../../../client/hooks.js'
+import { Message, useEffectOnce, getAuthErrorMessage } from '@wasp.sh/lib-sdk-core/browser'
 
 // PRIVATE API
 export const VerifyEmailForm = () => {
@@ -24,11 +23,8 @@ export const VerifyEmailForm = () => {
     try {
       await verifyEmail({ token })
       setSuccessMessage('Your email has been verified. You can now log in.')
-    } catch (error) {
-      setErrorMessage({
-        title: error.message,
-        description: error.data?.data?.message,
-      })
+    } catch (error: unknown) {
+      setErrorMessage(getAuthErrorMessage(error));
     } finally {
       setIsLoading(false)
     }

package/data/Generator/templates/sdk/wasp/auth/forms/internal/email/useEmail.ts

@@ -1,4 +1,4 @@
-import { signup } from '../../../email/actions/signup'
+import { signup, type EmailSignupData } from '../../../email/actions/signup'
 import { login } from '../../../email/actions/login'
 
 // PRIVATE API
@@ -8,12 +8,12 @@ export function useEmail({
   onLoginSuccess,
   isLogin,
 }: {
-  onError: (error: Error) => void
+  onError: (error: unknown) => void
   showEmailVerificationPending: () => void
   onLoginSuccess: () => void
   isLogin: boolean
 }) {
-  async function handleSubmit(data) {
+  async function handleSubmit(data: EmailSignupData): Promise<void> {
     try {
       if (isLogin) {
         await login(data)
@@ -22,8 +22,8 @@ export function useEmail({
         await signup(data)
         showEmailVerificationPending()
       }
-    } catch (err: unknown) {
-      onError(err as Error)
+    } catch (error: unknown) {
+      onError(error);
     }
   }
 

package/data/Generator/templates/sdk/wasp/auth/forms/internal/usernameAndPassword/useUsernameAndPassword.ts

@@ -1,4 +1,5 @@
-import { login, signup } from '../../../username'
+import { login } from '../../../username/actions/login'
+import { signup, type UsernameSignupData } from '../../../username/actions/signup'
 
 // PRIVATE API
 export function useUsernameAndPassword({
@@ -6,11 +7,11 @@ export function useUsernameAndPassword({
   onSuccess,
   isLogin,
 }: {
-  onError: (error: Error) => void
+  onError: (error: unknown) => void
   onSuccess: () => void
   isLogin: boolean
 }) {
-  async function handleSubmit(data) {
+  async function handleSubmit(data: UsernameSignupData): Promise<void> {
     try {
       if (!isLogin) {
         await signup(data)
@@ -18,8 +19,8 @@ export function useUsernameAndPassword({
       await login(data)
 
       onSuccess()
-    } catch (err: unknown) {
-      onError(err as Error)
+    } catch (error: unknown) {
+      onError(error);
     }
   }
 

package/data/Generator/templates/sdk/wasp/auth/forms/types.ts

@@ -1,6 +1,4 @@
 {{={= =}=}}
-import { UseFormReturn, RegisterOptions } from 'react-hook-form'
-import type { LoginSignupFormFields } from './internal/common/LoginSignupForm'
 
 // PRIVATE API
 export enum State {
@@ -12,60 +10,3 @@ export enum State {
   VerifyEmail = 'verify-email',
   {=/ isEmailAuthEnabled =}
 }
-
-// PUBLIC API
-export type CustomizationOptions = {
-  logo?: string
-  socialLayout?: 'horizontal' | 'vertical'
-  appearance?: {
-    // ATTENTION: Keep this list in sync with the one at `./internal/auth-styles.css`
-    colors?: {
-      waspYellow?: string,
-      gray700?: string,
-      gray600?: string,
-      gray500?: string,
-      gray400?: string,
-      red?: string,
-      darkRed?: string,
-      green?: string,
-
-      brand?: string,
-      brandAccent?: string,
-      errorBackground?: string,
-      errorText?: string,
-      successBackground?: string,
-      successText?: string,
-
-      submitButtonText?: string,
-
-      formErrorText?: string,
-    },
-    fontSizes?: {
-      sm?: string,
-    },
-  }
-}
-
-// PRIVATE API
-export type FormState = {
-  isLoading: boolean
-}
-
-// PRIVATE API
-export type AdditionalSignupFieldRenderFn = (
-  hookForm: UseFormReturn<LoginSignupFormFields>,
-  formState: FormState
-) => React.ReactNode
-
-// PRIVATE API
-export type AdditionalSignupField = {
-  name: string
-  label: string
-  type: 'input' | 'textarea'
-  validations?: RegisterOptions<LoginSignupFormFields>
-}
-
-// PRIVATE API
-export type AdditionalSignupFields =
-  | (AdditionalSignupField | AdditionalSignupFieldRenderFn)[]
-  | AdditionalSignupFieldRenderFn

package/data/Generator/templates/sdk/wasp/auth/helpers/_Provider.tsx

@@ -1,8 +1,8 @@
 {{={= =}=}}
 
 import { config } from '../../client/index.js'
-import { SocialButton } from '../forms/internal/social/SocialButton'
-import * as SocialIcons from '../forms/internal/social/SocialIcons'
+import { SocialButton } from '@wasp.sh/lib-sdk-core/browser'
+import * as SocialIcons from '@wasp.sh/lib-sdk-core/browser'
 
 // PUBLIC API
 export const signInUrl: string = `${config.apiUrl}{= signInPath =}`

package/data/Generator/templates/sdk/wasp/auth/index.ts

@@ -6,4 +6,4 @@ export {
 } from './user.js'
 
 // PUBLIC API
-export { type AuthUser } from '../server/auth/user.js'
+export type { AuthUser } from './user.js'

package/data/Generator/templates/sdk/wasp/auth/logout.ts

@@ -1,5 +1,5 @@
 import { api, removeLocalUserData } from '../api/index.js'
-import { invalidateAndRemoveQueries } from '../client/operations/internal/resources.js'
+import { invalidateAndRemoveQueries } from '@wasp.sh/lib-sdk-core/browser'
 
 // PUBLIC API
 export default async function logout(): Promise<void> {

package/data/Generator/templates/sdk/wasp/auth/providers/index.ts

@@ -1,9 +1,9 @@
 {{={= =}=}}
 
-{=# emailUserSignupFields.isDefined =}
+{=# isEmailUserSignupFieldsDefined =}
 export type { UserEmailSignupFields } from './types';
-{=/ emailUserSignupFields.isDefined =}
+{=/ isEmailUserSignupFieldsDefined =}
 
-{=# usernameAndPasswordUserSignupFields.isDefined =}
+{=# isUsernameAndPasswordUserSignupFieldsDefined =}
 export type { UserUsernameAndPasswordSignupFields } from './types';
-{=/ usernameAndPasswordUserSignupFields.isDefined =}
+{=/ isUsernameAndPasswordUserSignupFieldsDefined =}

package/data/Generator/templates/sdk/wasp/auth/providers/types.ts

@@ -1,8 +1,15 @@
 {{={= =}=}}
-import type { Router, Request } from 'express'
+import { type ProviderConfig, type RequestWithWasp } from '@wasp.sh/lib-sdk-core/node'
+export { type ProviderConfig, type RequestWithWasp } from '@wasp.sh/lib-sdk-core/node'
+
 import type { Prisma } from '@prisma/client'
-import type { Expand, Exact } from '../../universal/types.js'
-import type { ProviderName } from '../utils'
+import type { Exact, Expand, ProviderName } from '@wasp.sh/lib-sdk-core'
+{=# isEmailUserSignupFieldsDefined =}
+import type { FromRegister } from '../../types/register'
+{=/ isEmailUserSignupFieldsDefined =}
+{=# isUsernameAndPasswordUserSignupFieldsDefined =}
+import type { FromRegister } from '../../types/register'
+{=/ isUsernameAndPasswordUserSignupFieldsDefined =}
 
 // PUBLIC API
 export function defineUserSignupFields<T extends UserSignupFields>(
@@ -10,18 +17,20 @@ export function defineUserSignupFields<T extends UserSignupFields>(
 ): T {
   return fields
 }
+{=# isEmailUserSignupFieldsDefined =}
 
-{=# emailUserSignupFields.isDefined =}
-{=& emailUserSignupFields.importStatement =}
 // PUBLIC API
-export type UserEmailSignupFields = InferUserSignupFields<typeof {= emailUserSignupFields.importIdentifier =}>;
-{=/ emailUserSignupFields.isDefined =}
+export type UserEmailSignupFields = InferUserSignupFields<RegisteredEmailSignupFields>;
+
+type RegisteredEmailSignupFields = FromRegister<"emailUserSignupFields", {}>;
+{=/ isEmailUserSignupFieldsDefined =}
+{=# isUsernameAndPasswordUserSignupFieldsDefined =}
 
-{=# usernameAndPasswordUserSignupFields.isDefined =}
-{=& usernameAndPasswordUserSignupFields.importStatement =}
 // PUBLIC API
-export type UserUsernameAndPasswordSignupFields = InferUserSignupFields<typeof {= usernameAndPasswordUserSignupFields.importIdentifier =}>;
-{=/ usernameAndPasswordUserSignupFields.isDefined =}
+export type UserUsernameAndPasswordSignupFields = InferUserSignupFields<RegisteredUsernameAndPasswordSignupFields>;
+
+type RegisteredUsernameAndPasswordSignupFields = FromRegister<"usernameAndPasswordUserSignupFields", {}>
+{=/ isUsernameAndPasswordUserSignupFieldsDefined =}
 
 /**
  * Extracts the result types from a UserSignupFields object.
@@ -38,19 +47,6 @@ type InferUserSignupFields<T extends UserSignupFields> = {
 
 type UserEntityCreateInput = Prisma.{= userEntityUpper =}CreateInput
 
-// PRIVATE API
-export type ProviderConfig = {
-    // Unique provider identifier, used as part of URL paths
-    id: ProviderName;
-    displayName: string;
-    // Every provider must have a setupRouter method which returns the Express router.
-    // In this function we are flexibile to do what ever is necessary to make the provider work.
-    createRouter(provider: ProviderConfig): Router;
-};
-
-// PRIVATE API
-export type RequestWithWasp = Request & { wasp?: { [key: string]: any } }
-
 // PRIVATE API
 export type PossibleUserFields = Expand<Partial<UserEntityCreateInput>>
 

package/data/Generator/templates/sdk/wasp/auth/useAuth.ts

@@ -1,12 +1,12 @@
 {{={= =}=}}
 import { deserialize } from '../core/serialization/index.js'
-import { useQuery, buildAndRegisterQuery } from '../client/operations/index.js'
-import type { QueryFunction, Query  } from '../client/operations/rpc.js'
+import { buildAndRegisterQuery, useQuery } from '@wasp.sh/lib-sdk-core/browser'
+import type { QueryFunction, Query  } from '@wasp.sh/lib-sdk-core'
 import { api, handleApiError } from '../api/index.js'
 import { HttpMethod } from '../client/index.js'
-import type { AuthUser, AuthUserData } from '../server/auth/user.js'
-import { makeAuthUserIfPossible } from '../auth/user.js'
-import { UseQueryResult } from '@tanstack/react-query'
+import type { AuthUser, AuthUserData } from './user.js'
+import { makeAuthUserIfPossible } from './user.js'
+import type { UseQueryResult } from '@tanstack/react-query'
 
 // PUBLIC API
 export const getMe: Query<void, AuthUser | null> = createUserGetter()

package/data/Generator/templates/sdk/wasp/auth/user.ts

@@ -1,15 +1,16 @@
-import { type ProviderName } from '../server/_types/index.js'
+{{={= =}=}}
 import type {
-  AuthUserData,
-  AuthUser,
-  UserEntityWithAuth,
-} from '../server/auth/user.js'
-import { isNotNull } from '../universal/predicates.js'
-
-/**
- * We split the user.ts code into two files to avoid some server-only
- * code (Oslo's hashing functions) being imported on the client.
- */
+  {= userEntityName =},
+  {= authEntityName =},
+  {= authIdentityEntityName =},
+} from '../entities/index.js'
+import {
+  type PossibleProviderData,
+  type ProviderName,
+  getProviderData,
+  isNotNull,
+  type Expand,
+} from '@wasp.sh/lib-sdk-core'
 
 // PUBLIC API
 export function getEmail(user: UserEntityWithAuth): string | null {
@@ -27,11 +28,81 @@ export function getFirstProviderUserId(user?: UserEntityWithAuth): string | null
     return null;
   }
 
-  return user.auth.identities[0].providerUserId ?? null;
+  return user.auth.identities[0]?.providerUserId ?? null;
+}
+
+// PUBLIC API
+export type AuthUser = AuthUserData & {
+  getFirstProviderUserId: () => string | null,
 }
 
 // PRIVATE API (used in SDK and server)
-export type { AuthUserData, AuthUser } from '../server/auth/user.js'
+/*
+ * We write this type out instead of using `ReturnType<typeof createAuthUserData>`
+ * because `Expand` makes editors show each identity's fields on hover. The
+ * inferred type would show `UserFacingProviderData<"email">` instead.
+ */
+export type AuthUserData = Omit<CompleteUserEntityWithAuth, '{= authFieldOnUserEntityName =}'> & {
+  identities: {
+    {=# enabledProviders.isEmailAuthEnabled =}
+    email: Expand<UserFacingProviderData<'email'>> | null
+    {=/ enabledProviders.isEmailAuthEnabled =}
+    {=# enabledProviders.isUsernameAndPasswordAuthEnabled =}
+    username: Expand<UserFacingProviderData<'username'>> | null
+    {=/ enabledProviders.isUsernameAndPasswordAuthEnabled =}
+    {=# enabledProviders.isSlackAuthEnabled =}
+    slack: Expand<UserFacingProviderData<'slack'>> | null
+    {=/ enabledProviders.isSlackAuthEnabled =}
+    {=# enabledProviders.isDiscordAuthEnabled =}
+    discord: Expand<UserFacingProviderData<'discord'>> | null
+    {=/ enabledProviders.isDiscordAuthEnabled =}
+    {=# enabledProviders.isGoogleAuthEnabled =}
+    google: Expand<UserFacingProviderData<'google'>> | null
+    {=/ enabledProviders.isGoogleAuthEnabled =}
+    {=# enabledProviders.isKeycloakAuthEnabled =}
+    keycloak: Expand<UserFacingProviderData<'keycloak'>> | null
+    {=/ enabledProviders.isKeycloakAuthEnabled =}
+    {=# enabledProviders.isGitHubAuthEnabled =}
+    github: Expand<UserFacingProviderData<'github'>> | null
+    {=/ enabledProviders.isGitHubAuthEnabled =}
+    {=# enabledProviders.isMicrosoftAuthEnabled =}
+    microsoft: Expand<UserFacingProviderData<'microsoft'>> | null
+    {=/ enabledProviders.isMicrosoftAuthEnabled =}
+  },
+}
+
+type UserFacingProviderData<PN extends ProviderName> = {
+  id: string
+} & Omit<PossibleProviderData[PN], 'hashedPassword'>
+
+// PRIVATE API
+export type CompleteUserEntityWithAuth =
+  MakeUserEntityWithAuth<CompleteAuthEntityWithIdentities>
+
+// PRIVATE API
+export type CompleteAuthEntityWithIdentities =
+  MakeAuthEntityWithIdentities<{= authIdentityEntityName =}>
+
+// PRIVATE API
+/**
+ * User entity with all of the auth related data that's needed for the user facing
+ * helper functions like `getUsername` and `getEmail`.
+ */
+export type UserEntityWithAuth = MakeUserEntityWithAuth<
+  MakeAuthEntityWithIdentities<
+    // It's constructed like the Complete* types, but only with the fields needed
+    // for the user facing functions.
+    Pick<{= authIdentityEntityName =}, 'providerName' | 'providerUserId'>
+  >
+>
+
+type MakeUserEntityWithAuth<AuthType> = {= userEntityName =} & {
+  {= authFieldOnUserEntityName =}: AuthType | null
+}
+
+type MakeAuthEntityWithIdentities<IdentityType> = {= authEntityName =} & {
+  {= identitiesFieldOnAuthEntityName =}: IdentityType[]
+}
 
 // PRIVATE API (used in SDK and server)
 export function makeAuthUserIfPossible(user: null): null
@@ -48,11 +119,73 @@ function makeAuthUser(data: AuthUserData): AuthUser {
     ...data,
     getFirstProviderUserId: () => {
       const identities = Object.values(data.identities).filter(isNotNull);
-      return identities.length > 0 ? identities[0].id : null;
+      return identities[0]?.id ?? null;
     },
   };
 }
 
+// PRIVATE API
+export function createAuthUserData(user: CompleteUserEntityWithAuth): AuthUserData {
+  const { {= authFieldOnUserEntityName =}, ...rest } = user
+  if (!{= authFieldOnUserEntityName =}) {
+    throw new Error(`🐝 Error: trying to create a user without auth data.
+This should never happen, but it did which means there is a bug in the code.`)
+  }
+  const identities = {
+    {=# enabledProviders.isEmailAuthEnabled =}
+    email: getProviderInfo<'email'>({= authFieldOnUserEntityName =}, 'email'),
+    {=/ enabledProviders.isEmailAuthEnabled =}
+    {=# enabledProviders.isUsernameAndPasswordAuthEnabled =}
+    username: getProviderInfo<'username'>({= authFieldOnUserEntityName =}, 'username'),
+    {=/ enabledProviders.isUsernameAndPasswordAuthEnabled =}
+    {=# enabledProviders.isSlackAuthEnabled =}
+    slack: getProviderInfo<'slack'>({= authFieldOnUserEntityName =}, 'slack'),
+    {=/ enabledProviders.isSlackAuthEnabled =}
+    {=# enabledProviders.isDiscordAuthEnabled =}
+    discord: getProviderInfo<'discord'>({= authFieldOnUserEntityName =}, 'discord'),
+    {=/ enabledProviders.isDiscordAuthEnabled =}
+    {=# enabledProviders.isGoogleAuthEnabled =}
+    google: getProviderInfo<'google'>({= authFieldOnUserEntityName =}, 'google'),
+    {=/ enabledProviders.isGoogleAuthEnabled =}
+    {=# enabledProviders.isKeycloakAuthEnabled =}
+    keycloak: getProviderInfo<'keycloak'>({= authFieldOnUserEntityName =}, 'keycloak'),
+    {=/ enabledProviders.isKeycloakAuthEnabled =}
+    {=# enabledProviders.isGitHubAuthEnabled =}
+    github: getProviderInfo<'github'>({= authFieldOnUserEntityName =}, 'github'),
+    {=/ enabledProviders.isGitHubAuthEnabled =}
+    {=# enabledProviders.isMicrosoftAuthEnabled =}
+    microsoft: getProviderInfo<'microsoft'>({= authFieldOnUserEntityName =}, 'microsoft'),
+    {=/ enabledProviders.isMicrosoftAuthEnabled =}
+  }
+  return {
+    ...rest,
+    identities,
+  }
+}
+
+function getProviderInfo<PN extends ProviderName>(
+  auth: CompleteAuthEntityWithIdentities,
+  providerName: PN
+):
+  | UserFacingProviderData<PN>
+  | null {
+  const identity = getIdentity(auth, providerName)
+  if (!identity) {
+    return null
+  }
+  return {
+    ...getProviderData<PN>(identity.providerData),
+    id: identity.providerUserId,
+  }
+}
+
+function getIdentity(
+  auth: CompleteAuthEntityWithIdentities,
+  providerName: ProviderName
+): {= authIdentityEntityName =} | null {
+  return auth.{= identitiesFieldOnAuthEntityName =}.find((i) => i.providerName === providerName) ?? null
+}
+
 function findUserIdentity(user: UserEntityWithAuth, providerName: ProviderName): NonNullable<UserEntityWithAuth['auth']>['identities'][number] | null {
   if (!user.auth) {
     return null;

package/data/Generator/templates/sdk/wasp/auth/username/actions/login.ts

@@ -1,7 +1,7 @@
 {{={= =}=}}
 import { api, handleApiError } from '../../../api/index.js'
-import { initSession } from '../../helpers/user'
-import { SessionResponseSchema } from '../../responseSchemas'
+import { initSession } from '@wasp.sh/lib-sdk-core/browser'
+import { SessionResponseSchema } from '@wasp.sh/lib-sdk-core'
 
 export async function login(data: { username: string, password: string }): Promise<void> {
   try {

package/data/Generator/templates/sdk/wasp/auth/username/actions/signup.ts

@@ -1,13 +1,14 @@
 {{={= =}=}}
 import { api, handleApiError } from '../../../api/index.js'
-{=# usernameAndPasswordUserSignupFields.isDefined =}
-import { type UserUsernameAndPasswordSignupFields } from '../../providers'
-{=/ usernameAndPasswordUserSignupFields.isDefined =}
+{=# isUsernameAndPasswordUserSignupFieldsDefined =}
+import type { UserUsernameAndPasswordSignupFields } from '../../providers'
+{=/ isUsernameAndPasswordUserSignupFieldsDefined =}
 
-type UsernameSignupData = {
+// PRIVATE API
+export type UsernameSignupData = {
   username: string
   password: string
-}{=# usernameAndPasswordUserSignupFields.isDefined =} & UserUsernameAndPasswordSignupFields{=/ usernameAndPasswordUserSignupFields.isDefined =}
+}{=# isUsernameAndPasswordUserSignupFieldsDefined =} & UserUsernameAndPasswordSignupFields{=/ isUsernameAndPasswordUserSignupFieldsDefined =}
 
 // PUBLIC API
 export async function signup(data: UsernameSignupData): Promise<void> {

package/data/Generator/templates/sdk/wasp/auth/validation.ts

@@ -1,83 +1 @@
-import { HttpError } from '../server/index.js';
-
-export const PASSWORD_FIELD = 'password';
-const USERNAME_FIELD = 'username';
-const EMAIL_FIELD = 'email';
-const TOKEN_FIELD = 'token';
-
-// PUBLIC API
-export function ensureValidEmail(args: object): void {
-  validate(args, [
-    { validates: EMAIL_FIELD, message: 'email must be present', validator: email => !!email },
-    { validates: EMAIL_FIELD, message: 'email must be a valid email', validator: email => isValidEmail(email) },
-  ]);
-}
-
-// PUBLIC API
-export function ensureValidUsername(args: object): void {
-  validate(args, [
-    { validates: USERNAME_FIELD, message: 'username must be present', validator: username => !!username }
-  ]);
-}
-
-// PUBLIC API
-export function ensurePasswordIsPresent(args: object): void {
-  validate(args, [
-    { validates: PASSWORD_FIELD, message: 'password must be present', validator: password => !!password },
-  ]);
-}
-
-// PUBLIC API
-export function ensureValidPassword(args: object): void {
-  validate(args, [
-    { validates: PASSWORD_FIELD, message: 'password must be at least 8 characters', validator: password => isMinLength(password, 8) },
-    { validates: PASSWORD_FIELD, message: 'password must contain a number', validator: password => containsNumber(password) },
-  ]);
-}
-
-// PUBLIC API
-export function ensureTokenIsPresent(args: object): void {
-  validate(args, [
-    { validates: TOKEN_FIELD, message: 'token must be present', validator: token => !!token },
-  ]);
-}
-
-// PRIVATE API
-export function throwValidationError(message: string): void {
-  throw new HttpError(422, 'Validation failed', { message })
-}
-
-function validate(args: object, validators: { validates: string, message: string, validator: (value: unknown) => boolean }[]): void {
-  for (const { validates, message, validator } of validators) {
-    if (!validator(args[validates])) {
-      throwValidationError(message);
-    }
-  }
-}
-
-// NOTE(miho): it would be good to replace our custom validations with e.g. Zod
-
-const validEmailRegex = /(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/
-function isValidEmail(input: unknown): boolean {
-    if (typeof input !== 'string') {
-        return false
-    }
-
-    return input.match(validEmailRegex) !== null
-}
-
-function isMinLength(input: unknown, minLength: number): boolean {
-    if (typeof input !== 'string') {
-        return false
-    }
-
-    return input.length >= minLength
-}
-
-function containsNumber(input: unknown): boolean {
-    if (typeof input !== 'string') {
-        return false
-    }
-
-    return /\d/.test(input)
-}
+export { ensurePasswordIsPresent, ensureTokenIsPresent, ensureValidEmail, ensureValidPassword, ensureValidUsername, PASSWORD_FIELD, throwValidationError } from '@wasp.sh/lib-sdk-core'

package/data/Generator/templates/sdk/wasp/client/app/pages/OAuthCallback.tsx

@@ -3,10 +3,13 @@ import { useState } from "react";
 import { Navigate, useLocation } from 'react-router'
 import { useAuth } from "../../auth";
 import { api } from "../../../api";
-import { initSession } from "../../../auth/helpers/user";
-import { useEffectOnce } from "../../hooks";
-import { MessageLoading, MessageError } from "../components/Message";
-import { FullPageWrapper } from "../components/FullPageWrapper";
+import {
+  FullPageWrapper,
+  initSession,
+  MessageError,
+  MessageLoading,
+  useEffectOnce,
+} from "@wasp.sh/lib-sdk-core/browser";
 
 const oAuthCallbackWrapperClassName = "wasp-oauth-callback-wrapper";
 
@@ -14,7 +17,7 @@ export function OAuthCallbackPage() {
   const { error, user } = useOAuthCallbackHandler();
 
   if (user !== undefined && user !== null) {
-    return <Navigate to="{= onAuthSucceededRedirectTo =}" replace />;
+    return <Navigate to={{=& onAuthSucceededRedirectTo =}} replace />;
   }
 
 

package/data/Generator/templates/sdk/wasp/client/app/pages/createAuthRequiredPage.jsx

@@ -4,9 +4,11 @@ import * as React from 'react'
 import { Navigate } from 'react-router'
 import { useAuth } from '../../auth'
 
-import { Loader } from '../components/Loader'
-import { MessageError } from '../components/Message'
-import { FullPageWrapper } from '../components/FullPageWrapper'
+import {
+  FullPageWrapper,
+  Loader,
+  MessageError,
+} from '@wasp.sh/lib-sdk-core/browser'
 
 export const createAuthRequiredPage = (Page) => {
   return (props) => {
@@ -17,7 +19,7 @@ export const createAuthRequiredPage = (Page) => {
         if (user) {
           return <Page {...props} user={user} />
         } else {
-          return <Navigate to="{= onAuthFailedRedirectTo =}" replace />
+          return <Navigate to={{=& onAuthFailedRedirectTo =}} replace />
         }
       case 'loading':
         return (

package/data/Generator/templates/sdk/wasp/client/app/router.tsx

@@ -6,7 +6,7 @@ import type { RouteObject } from 'react-router'
 import { OAuthCallbackPage } from "./pages/OAuthCallback"
 {=/ isExternalAuthEnabled =}
 
-import { DefaultRootErrorBoundary } from './components/DefaultRootErrorBoundary'
+import { DefaultRootErrorBoundary } from '@wasp.sh/lib-sdk-core/browser'
 
 import { routes } from '../router/index'
 
@@ -19,7 +19,7 @@ export function getRouteObjects({
   routesMapping: RouteMapping,
   rootElement: ReactNode,
 }): RouteObject[] {
-  const waspDefinedRoutes = [
+  const waspDefinedRoutes: RouteObject[] = [
     {=# isExternalAuthEnabled =}
     {
       path: "{= oAuthCallbackPath =}",