Enables strict null checks in SDK

waspc/data/Generator/templates/sdk/wasp/api/index.ts

@@ -77,7 +77,7 @@ window.addEventListener('storage', (event) => {
  * standard format to be further used by the client. It is also assumed that given API
  * error has been formatted as implemented by HttpError on the server.
  */
-export function handleApiError(error: AxiosError<{ message?: string, data?: unknown }>): void {
+export function handleApiError<T extends AxiosError<{ message?: string, data?: unknown }>>(error: T): T | WaspHttpError {
   if (error?.response) {
     // If error came from HTTP response, we capture most informative message
     // and also add .statusCode information to it.
@@ -88,10 +88,10 @@ export function handleApiError(error: AxiosError<{ message?: string, data?: unkn
     //   That would require copying HttpError code to web-app also and using it here.
     const responseJson = error.response?.data
     const responseStatusCode = error.response.status
-    throw new WaspHttpError(responseStatusCode, responseJson?.message ?? error.message, responseJson)
+    return new WaspHttpError(responseStatusCode, responseJson?.message ?? error.message, responseJson)
   } else {
     // If any other error, we just propagate it.
-    throw error
+    return error
   }
 }
 

waspc/data/Generator/templates/sdk/wasp/auth/email/actions/login.ts

@@ -8,6 +8,6 @@ export async function login(data: { email: string; password: string }): Promise<
         const response = await api.post('{= loginPath =}', data);
         await initSession(response.data.sessionId);
     } catch (e) {
-        handleApiError(e);
+        throw handleApiError(e);
     }
 }

waspc/data/Generator/templates/sdk/wasp/auth/email/actions/passwordReset.ts

@@ -7,7 +7,7 @@ export async function requestPasswordReset(data: { email: string; }): Promise<{
         const response = await api.post('{= requestPasswordResetPath =}', data);
         return response.data;
     } catch (e) {
-        handleApiError(e);
+        throw handleApiError(e);
     }
 }
 
@@ -17,6 +17,6 @@ export async function resetPassword(data: { token: string; password: string; }):
         const response = await api.post('{= resetPasswordPath =}', data);
         return response.data;
     } catch (e) {
-        handleApiError(e);
+        throw handleApiError(e);
     }
 }

waspc/data/Generator/templates/sdk/wasp/auth/email/actions/signup.ts

@@ -7,6 +7,6 @@ export async function signup(data: { email: string; password: string }): Promise
         const response = await api.post('{= signupPath =}', data);
         return response.data;
     } catch (e) {
-        handleApiError(e);
+        throw handleApiError(e);
     }
 }

waspc/data/Generator/templates/sdk/wasp/auth/email/actions/verifyEmail.ts

@@ -9,6 +9,6 @@ export async function verifyEmail(data: {
     const response = await api.post('{= verifyEmailPath =}', data)
     return response.data
   } catch (e) {
-    handleApiError(e)
+    throw handleApiError(e)
   }
 }

waspc/data/Generator/templates/sdk/wasp/auth/forms/internal/common/LoginSignupForm.tsx

@@ -280,7 +280,7 @@ function AdditionalFormFields({
 }: {
   hookForm: UseFormReturn<LoginSignupFormFields>;
   formState: FormState;
-  additionalSignupFields: AdditionalSignupFields;
+  additionalSignupFields?: AdditionalSignupFields;
 }) {
   const {
     register,
@@ -302,7 +302,7 @@ function AdditionalFormFields({
           disabled={isLoading}
         />
         {errors[field.name] && (
-          <FormError>{errors[field.name].message}</FormError>
+          <FormError>{errors[field.name]!.message}</FormError>
         )}
       </FormItemGroup>
     );
@@ -341,7 +341,7 @@ function isFieldRenderFn(
 }
 
 function areAdditionalFieldsRenderFn(
-  additionalSignupFields: AdditionalSignupFields
+  additionalSignupFields?: AdditionalSignupFields
 ): additionalSignupFields is AdditionalSignupFieldRenderFn {
   return typeof additionalSignupFields === 'function'
 }

waspc/data/Generator/templates/sdk/wasp/auth/login.ts

@@ -9,6 +9,6 @@ export default async function login(username: string, password: string): Promise
 
     await initSession(response.data.sessionId)
   } catch (error) {
-    handleApiError(error)
+    throw handleApiError(error)
   }
 }

waspc/data/Generator/templates/sdk/wasp/auth/session.ts

@@ -6,7 +6,7 @@ import { type AuthUserData } from '../server/auth/user.js';
 
 import { auth } from "./lucia.js";
 import type { Session } from "lucia";
-import { throwInvalidCredentialsError } from "./utils.js";
+import { createInvalidCredentialsError } from "./utils.js";
 
 import { prisma } from 'wasp/server';
 import { createAuthUserData } from "../server/auth/user.js";
@@ -66,7 +66,7 @@ async function getAuthUserData(userId: {= userEntityUpper =}['id']): Promise<Aut
     })
 
   if (!user) {
-    throwInvalidCredentialsError()
+    throw createInvalidCredentialsError()
   }
 
   return createAuthUserData(user);

waspc/data/Generator/templates/sdk/wasp/auth/signup.ts

@@ -5,6 +5,6 @@ export default async function signup(userFields: { username: string; password: s
   try {
     await api.post('{= signupPath =}', userFields)
   } catch (error) {
-    handleApiError(error)
+    throw handleApiError(error)
   }
 }

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

@@ -28,7 +28,7 @@ function createUserGetter(): Query<void, AuthUser | null> {
       if (error.response?.status === 401) {
         return null
       } else {
-        handleApiError(error)
+        throw handleApiError(error)
       }
     }
   }

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

@@ -4,6 +4,7 @@ import type {
   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
@@ -35,6 +36,7 @@ export type { AuthUserData, AuthUser } from '../server/auth/user.js'
 // PRIVATE API (used in SDK and server)
 export function makeAuthUserIfPossible(user: null): null
 export function makeAuthUserIfPossible(user: AuthUserData): AuthUser
+export function makeAuthUserIfPossible(user: AuthUserData | null): AuthUser | null
 export function makeAuthUserIfPossible(
   user: AuthUserData | null,
 ): AuthUser | null {
@@ -45,13 +47,13 @@ function makeAuthUser(data: AuthUserData): AuthUser {
   return {
     ...data,
     getFirstProviderUserId: () => {
-      const identities = Object.values(data.identities).filter(Boolean);
+      const identities = Object.values(data.identities).filter(isNotNull);
       return identities.length > 0 ? identities[0].id : null;
     },
   };
 }
 
-function findUserIdentity(user: UserEntityWithAuth, providerName: ProviderName): UserEntityWithAuth['auth']['identities'][number] | null {
+function findUserIdentity(user: UserEntityWithAuth, providerName: ProviderName): NonNullable<UserEntityWithAuth['auth']>['identities'][number] | null {
   if (!user.auth) {
     return null;
   }

waspc/data/Generator/templates/sdk/wasp/auth/utils.ts

@@ -110,7 +110,7 @@ export async function updateAuthIdentityProviderData<PN extends ProviderName>(
 ): Promise<{= authIdentityEntityUpper =}> {
   // We are doing the sanitization here only on updates to avoid
   // hashing the password multiple times.
-  const sanitizedProviderDataUpdates = await sanitizeProviderData(providerDataUpdates);
+  const sanitizedProviderDataUpdates = await ensurePasswordIsHashed(providerDataUpdates);
   const newProviderData = {
     ...existingProviderData,
     ...sanitizedProviderDataUpdates,
@@ -124,25 +124,39 @@ export async function updateAuthIdentityProviderData<PN extends ProviderName>(
   });
 }
 
-type FindAuthWithUserResult = {= authEntityUpper =} & {
+// PRIVATE API
+export type FindAuthWithUserResult = {= authEntityUpper =} & {
   {= userFieldOnAuthEntityName =}: {= userEntityUpper =}
 }
 
 // PRIVATE API
 export async function findAuthWithUserBy(
   where: Prisma.{= authEntityUpper =}WhereInput
-): Promise<FindAuthWithUserResult> {
-  return prisma.{= authEntityLower =}.findFirst({ where, include: { {= userFieldOnAuthEntityName =}: true }});
+): Promise<FindAuthWithUserResult | null> {
+  const result = await prisma.{= authEntityLower =}.findFirst({ where, include: { {= userFieldOnAuthEntityName =}: true }});
+
+  if (result === null) {
+    return null;
+  }
+
+  if (result.user === null) {
+    return null;
+  }
+
+  return result as FindAuthWithUserResult;
+}
+
+// PUBLIC API
+export type CreateUserResult = {= userEntityUpper =} & {
+  auth: {= authEntityUpper =} | null
 }
 
 // PUBLIC API
 export async function createUser(
   providerId: ProviderId,
   serializedProviderData?: string,
   userFields?: PossibleUserFields,
-): Promise<{= userEntityUpper =} & {
-  auth: {= authEntityUpper =}
-}> {
+): Promise<CreateUserResult> {
   return prisma.{= userEntityLower =}.create({
     data: {
       // Using any here to prevent type errors when userFields are not
@@ -261,34 +275,45 @@ export async function validateAndGetUserFields(
 }
 
 // PUBLIC API
-export function deserializeAndSanitizeProviderData<PN extends ProviderName>(
+export function getProviderData<PN extends ProviderName>(
+  providerData: string,
+):  Omit<PossibleProviderData[PN], 'hashedPassword'> {
+  return sanitizeProviderData(getProviderDataWithPassword(providerData));
+}
+
+// PUBLIC API
+export function getProviderDataWithPassword<PN extends ProviderName>(
   providerData: string,
-  { shouldRemovePasswordField = false }: { shouldRemovePasswordField?: boolean } = {},
 ): PossibleProviderData[PN] {
   // NOTE: We are letting JSON.parse throw an error if the providerData is not valid JSON.
-  let data = JSON.parse(providerData) as PossibleProviderData[PN];
+  return JSON.parse(providerData) as PossibleProviderData[PN];
+}
 
-  if (providerDataHasPasswordField(data) && shouldRemovePasswordField) {
-    delete data.hashedPassword;
+function sanitizeProviderData<PN extends ProviderName>(
+  providerData: PossibleProviderData[PN],
+): Omit<PossibleProviderData[PN], 'hashedPassword'> {
+  if (providerDataHasPasswordField(providerData)) {
+    const { hashedPassword, ...rest } = providerData;
+    return rest;
+  } else {
+    return providerData;
   }
-
-  return data;
 }
 
 // PUBLIC API
 export async function sanitizeAndSerializeProviderData<PN extends ProviderName>(
   providerData: PossibleProviderData[PN],
 ): Promise<string> {
   return serializeProviderData(
-    await sanitizeProviderData(providerData)
+    await ensurePasswordIsHashed(providerData)
   );
 }
 
 function serializeProviderData<PN extends ProviderName>(providerData: PossibleProviderData[PN]): string {
   return JSON.stringify(providerData);
 }
 
-async function sanitizeProviderData<PN extends ProviderName>(
+async function ensurePasswordIsHashed<PN extends ProviderName>(
   providerData: PossibleProviderData[PN],
 ): Promise<PossibleProviderData[PN]> {
   const data = {
@@ -309,6 +334,6 @@ function providerDataHasPasswordField(
 }
 
 // PRIVATE API
-export function throwInvalidCredentialsError(message?: string): void {
-  throw new HttpError(401, 'Invalid credentials', { message })
+export function createInvalidCredentialsError(message?: string): HttpError {
+  return new HttpError(401, 'Invalid credentials', { message })
 }

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

@@ -6,37 +6,37 @@ const EMAIL_FIELD = 'email';
 const TOKEN_FIELD = 'token';
 
 // PUBLIC API
-export function ensureValidEmail(args: unknown): void {
+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: unknown): void {
+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: unknown): void {
+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: unknown): void {
+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: unknown): void {
+export function ensureTokenIsPresent(args: object): void {
   validate(args, [
     { validates: TOKEN_FIELD, message: 'token must be present', validator: token => !!token },
   ]);
@@ -47,7 +47,7 @@ export function throwValidationError(message: string): void {
   throw new HttpError(422, 'Validation failed', { message })
 }
 
-function validate(args: unknown, validators: { validates: string, message: string, validator: (value: unknown) => boolean }[]): void {
+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);

waspc/data/Generator/templates/sdk/wasp/client/config.ts

@@ -1,5 +1,5 @@
 {{={= =}=}}
-import { stripTrailingSlash } from 'wasp/universal/url'
+import { stripTrailingSlash } from '../universal/url.js'
 
 const apiUrl = stripTrailingSlash(import.meta.env.REACT_APP_API_URL) || '{= defaultServerUrl =}';
 

waspc/data/Generator/templates/sdk/wasp/client/operations/hooks.ts

@@ -28,8 +28,12 @@ export function useQuery<Input, Output>(
   return rqUseQuery({
     // todo: The full queryCacheKey is constructed in two places, both here and
     // inside the Query. See https://github.com/wasp-lang/wasp/issues/2017
-    queryKey: makeQueryCacheKey(query, queryFnArgs),
-    queryFn: () => query(queryFnArgs),
+    // FIXME: query fns don't handle the `undefined` case correctly
+    // https://github.com/wasp-lang/wasp/issues/2017
+    queryKey: makeQueryCacheKey(query, (queryFnArgs as Input)),
+    // FIXME: query fns don't handle the `undefined` case correctly
+    // https://github.com/wasp-lang/wasp/issues/2017
+    queryFn: () => query(queryFnArgs as Input),
     ...options,
   })
 }
@@ -138,7 +142,7 @@ type InternalOptimisticUpdateDefinition<ActionInput, CachedData> = {
  * the current state of the cache and returns the desired (new) state of the
  * cache.
  */
-type SpecificUpdateQuery<CachedData> = (oldData: CachedData) => CachedData;
+type SpecificUpdateQuery<CachedData> = (oldData: CachedData | undefined) => CachedData;
 
 /**
  * A specific, "instantiated" optimistic update definition which contains a
@@ -170,7 +174,7 @@ function translateToInternalDefinition<Item, CachedData>(
 ): InternalOptimisticUpdateDefinition<Item, CachedData> {
   const { getQuerySpecifier, updateQuery } = publicOptimisticUpdateDefinition;
 
-  const definitionErrors = [];
+  const definitionErrors: string[] = [];
   if (typeof getQuerySpecifier !== "function") {
     definitionErrors.push("`getQuerySpecifier` is not a function.");
   }
@@ -204,7 +208,7 @@ function makeOptimisticUpdateMutationFn<Input, Output, CachedData>(
     CachedData
   >[]
 ): typeof actionFn {
-  return (function performActionWithOptimisticUpdates(item?: Input) {
+  return (function performActionWithOptimisticUpdates(item: Input) {
     const specificOptimisticUpdateDefinitions = optimisticUpdateDefinitions.map(
       (generalDefinition) =>
         getOptimisticUpdateDefinitionForSpecificItem(generalDefinition, item)
@@ -259,10 +263,10 @@ function makeRqOptimisticUpdateOptions<ActionInput, CachedData>(
     );
 
     // We're using a Map to correctly serialize query keys that contain objects.
-    const previousData = new Map();
+    const previousData: Map<QueryKey, CachedData | undefined> = new Map();
     specificOptimisticUpdateDefinitions.forEach(({ queryKey, updateQuery }) => {
       // Snapshot the currently cached value.
-      const previousDataForQuery: CachedData =
+      const previousDataForQuery: CachedData | undefined =
         queryClient.getQueryData(queryKey);
 
       // Attempt to optimistically update the cache using the new value.