@wasp.sh/wasp-cli-darwin-x64-unknown 0.20.0

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

@@ -0,0 +1,20 @@
+{{={= =}=}}
+import { api, handleApiError } from 'wasp/client/api'
+{=# usernameAndPasswordUserSignupFields.isDefined =}
+import { type UserUsernameAndPasswordSignupFields } from '../../providers'
+{=/ usernameAndPasswordUserSignupFields.isDefined =}
+
+type UsernameSignupData = {
+  username: string
+  password: string
+}{=# usernameAndPasswordUserSignupFields.isDefined =} & UserUsernameAndPasswordSignupFields{=/ usernameAndPasswordUserSignupFields.isDefined =}
+
+// PUBLIC API
+export async function signup(data: UsernameSignupData): Promise<void> {
+  try {
+    await api.post('{= signupPath =}', data)
+  } catch (error) {
+    throw handleApiError(error)
+  }
+}
+

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

@@ -0,0 +1,2 @@
+export { login } from './actions/login'
+export { signup } from './actions/signup'

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

@@ -0,0 +1,369 @@
+{{={= =}=}}
+import { hashPassword } from './password.js'
+import { prisma, HttpError } from 'wasp/server'
+import { sleep } from 'wasp/server/utils'
+import {
+  type {= userEntityUpper =},
+  type {= authEntityUpper =},
+  type {= authIdentityEntityUpper =},
+} from 'wasp/entities'
+import { Prisma } from '@prisma/client';
+
+import { throwValidationError } from './validation.js'
+
+import { type UserSignupFields, type PossibleUserFields } from './providers/types.js'
+
+// PUBLIC API
+export type EmailProviderData = {
+  hashedPassword: string;
+  isEmailVerified: boolean;
+  emailVerificationSentAt: string | null;
+  passwordResetSentAt: string | null;
+}
+
+// PUBLIC API
+export type UsernameProviderData = {
+  hashedPassword: string;
+}
+
+// PUBLIC API
+export type OAuthProviderData = {}
+
+// PRIVATE API
+/**
+ * This type is used for type-level programming e.g. to enumerate
+ * all possible provider data types.
+ * 
+ * The keys of this type are the names of the providers and the values
+ * are the types of the provider data.
+ */
+export type PossibleProviderData = {
+  email: EmailProviderData;
+  username: UsernameProviderData;
+  discord: OAuthProviderData;
+  slack: OAuthProviderData;
+  google: OAuthProviderData;
+  keycloak: OAuthProviderData;
+  github: OAuthProviderData;
+}
+
+// PUBLIC API
+export type ProviderName = keyof PossibleProviderData
+
+// PRIVATE API
+export const contextWithUserEntity = {
+  entities: {
+    {= userEntityUpper =}: prisma.{= userEntityLower =}
+  }
+}
+
+// PRIVATE API
+export const authConfig = {
+  failureRedirectPath: "{= failureRedirectPath =}",
+  successRedirectPath: "{= successRedirectPath =}",
+}
+
+// PUBLIC API
+/**
+ * ProviderId uniquely identifies an auth identity e.g. 
+ * "email" provider with user id "test@test.com" or
+ * "google" provider with user id "1234567890".
+ * 
+ * We use this type to avoid passing the providerName and providerUserId
+ * separately. Also, we can normalize the providerUserId to make sure it's
+ * consistent across different DB operations.
+ */
+export type ProviderId = {
+  providerName: ProviderName;
+  providerUserId: string;
+}
+
+// PUBLIC API
+export function createProviderId(providerName: ProviderName, providerUserId: string): ProviderId {
+  return {
+    providerName,
+    providerUserId: normalizeProviderUserId(providerName, providerUserId),
+  }
+}
+
+// PRIVATE API
+export function normalizeProviderUserId(providerName: ProviderName, providerUserId: string): string {
+  switch (providerName) {
+    case 'email':
+    case 'username':
+      return providerUserId.toLowerCase();
+    case 'google':
+    case 'github':
+    case 'discord':
+    case 'keycloak':
+    case 'slack':
+      return providerUserId;
+    /*
+      Why the default case?
+      In case users add a new auth provider in the user-land.
+      Users can't extend this function because it is private.
+      If there is an unknown `providerName` in runtime, we'll
+      return the `providerUserId` as is.
+
+      We want to still have explicit OAuth providers listed
+      so that we get a type error if we forget to add a new provider
+      to the switch statement.
+    */
+    default:
+      providerName satisfies never;
+      return providerUserId;
+  }
+}
+
+// PUBLIC API
+export async function findAuthIdentity(providerId: ProviderId): Promise<{= authIdentityEntityUpper =} | null> {
+  return prisma.{= authIdentityEntityLower =}.findUnique({
+    where: {
+      providerName_providerUserId: providerId,
+    }
+  });
+}
+
+// PUBLIC API
+/**
+ * Updates the provider data for the given auth identity.
+ * 
+ * This function performs data sanitization and serialization.
+ * Sanitization is done by hashing the password, so this function
+ * expects the password received in the `providerDataUpdates`
+ * **not to be hashed**.
+ */
+export async function updateAuthIdentityProviderData<PN extends ProviderName>(
+  providerId: ProviderId,
+  existingProviderData: PossibleProviderData[PN],
+  providerDataUpdates: Partial<PossibleProviderData[PN]>,
+): Promise<{= authIdentityEntityUpper =}> {
+  // We are doing the sanitization here only on updates to avoid
+  // hashing the password multiple times.
+  const sanitizedProviderDataUpdates = await ensurePasswordIsHashed(providerDataUpdates);
+  const newProviderData = {
+    ...existingProviderData,
+    ...sanitizedProviderDataUpdates,
+  }
+  const serializedProviderData = await serializeProviderData<PN>(newProviderData);
+  return prisma.{= authIdentityEntityLower =}.update({
+    where: {
+      providerName_providerUserId: providerId,
+    },
+    data: { providerData: serializedProviderData },
+  });
+}
+
+// PRIVATE API
+export type FindAuthWithUserResult = {= authEntityUpper =} & {
+  {= userFieldOnAuthEntityName =}: {= userEntityUpper =}
+}
+
+// PRIVATE API
+export async function findAuthWithUserBy(
+  where: Prisma.{= authEntityUpper =}WhereInput
+): 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, user: result.user };
+}
+
+// PUBLIC API
+export type CreateUserResult = {= userEntityUpper =} & {
+  auth: {= authEntityUpper =} | null
+}
+
+// PUBLIC API
+export async function createUser(
+  providerId: ProviderId,
+  serializedProviderData?: string,
+  userFields?: PossibleUserFields,
+): Promise<CreateUserResult> {
+  return prisma.{= userEntityLower =}.create({
+    data: {
+      // Using any here to prevent type errors when userFields are not
+      // defined. We want Prisma to throw an error in that case.
+      ...(userFields ?? {} as any),
+      {= authFieldOnUserEntityName =}: {
+        create: {
+          {= identitiesFieldOnAuthEntityName =}: {
+              create: {
+                  providerName: providerId.providerName,
+                  providerUserId: providerId.providerUserId,
+                  providerData: serializedProviderData,
+              },
+          },
+        }
+      },
+    },
+    // We need to include the Auth entity here because we need `authId`
+    // to be able to create a session.
+    include: {
+      {= authFieldOnUserEntityName =}: true,
+    },
+  })
+}
+
+// PRIVATE API
+export async function deleteUserByAuthId(authId: string): Promise<{ count: number }> {
+  return prisma.{= userEntityLower =}.deleteMany({ where: { auth: {
+    id: authId,
+  } } })
+}
+
+// PRIVATE API
+// If an user exists, we don't want to leak information
+// about it. Pretending that we're doing some work
+// will make it harder for an attacker to determine
+// if a user exists or not.
+// NOTE: Attacker measuring time to response can still determine
+// if a user exists or not. We'll be able to avoid it when 
+// we implement e-mail sending via jobs.
+export async function doFakeWork(): Promise<unknown> {
+  const timeToWork = Math.floor(Math.random() * 1000) + 1000;
+  return sleep(timeToWork);
+}
+
+// PRIVATE API
+export function rethrowPossibleAuthError(e: unknown): void {
+  // Prisma code P2002 is for unique constraint violations.
+  if (e instanceof Prisma.PrismaClientKnownRequestError && e.code === 'P2002') {
+    throw new HttpError(422, 'Save failed', {
+      message: `user with the same identity already exists`,
+    })
+  }
+
+  if (e instanceof Prisma.PrismaClientValidationError) {
+    // NOTE: Logging the error since this usually means that there are
+    // required fields missing in the request, we want the developer
+    // to know about it.
+    console.error(e)
+    throw new HttpError(422, 'Save failed', {
+      message: 'there was a database error'
+    })
+  }
+
+  // Prisma code P2021 is for missing table errors.
+  if (e instanceof Prisma.PrismaClientKnownRequestError && e.code === 'P2021') {
+    // NOTE: Logging the error since this usually means that the database
+    // migrations weren't run, we want the developer to know about it.
+    console.error(e)
+    console.info('🐝 This error can happen if you did\'t run the database migrations.')
+    throw new HttpError(500, 'Save failed', {
+      message: `there was a database error`,
+    })
+  }
+
+  // Prisma code P2003 is for foreign key constraint failure
+  if (e instanceof Prisma.PrismaClientKnownRequestError && e.code === 'P2003') {
+    console.error(e)
+    console.info(`🐝 This error can happen if you have some relation on your {= userEntityUpper =} entity
+   but you didn't specify the "onDelete" behaviour to either "Cascade" or "SetNull".
+   Read more at: https://www.prisma.io/docs/orm/prisma-schema/data-model/relations/referential-actions`)
+    throw new HttpError(500, 'Save failed', {
+      message: `there was a database error`,
+    })
+  }
+
+  throw e
+}
+
+// PRIVATE API
+export async function validateAndGetUserFields(
+  data: {
+    [key: string]: unknown
+  },
+  userSignupFields?: UserSignupFields,
+): Promise<Record<string, any>> {
+  const {
+    password: _password,
+    ...sanitizedData
+  } = data;
+  const result: Record<string, any> = {};
+
+  if (!userSignupFields) {
+    return result;
+  }
+
+  for (const [field, getFieldValue] of Object.entries(userSignupFields)) {
+    try {
+      const value = await getFieldValue(sanitizedData)
+      result[field] = value
+    } catch (e) {
+      throwValidationError(e.message)
+    }
+  }
+  return result;
+}
+
+// PUBLIC API
+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,
+): PossibleProviderData[PN] {
+  // NOTE: We are letting JSON.parse throw an error if the providerData is not valid JSON.
+  return JSON.parse(providerData);
+}
+
+function sanitizeProviderData<PN extends ProviderName>(
+  providerData: PossibleProviderData[PN],
+): Omit<PossibleProviderData[PN], 'hashedPassword'> {
+  if (providerDataHasPasswordField(providerData)) {
+    const { hashedPassword, ...rest } = providerData;
+    return rest;
+  } else {
+    return providerData;
+  }
+}
+
+// PUBLIC API
+export async function sanitizeAndSerializeProviderData<PN extends ProviderName>(
+  providerData: PossibleProviderData[PN],
+): Promise<string> {
+  return serializeProviderData(
+    await ensurePasswordIsHashed(providerData)
+  );
+}
+
+function serializeProviderData<PN extends ProviderName>(providerData: PossibleProviderData[PN]): string {
+  return JSON.stringify(providerData);
+}
+
+async function ensurePasswordIsHashed<PN extends ProviderName>(
+  providerData: PossibleProviderData[PN],
+): Promise<PossibleProviderData[PN]> {
+  const data = {
+    ...providerData,
+  };
+  if (providerDataHasPasswordField(data)) {
+    data.hashedPassword = await hashPassword(data.hashedPassword);
+  }
+
+  return data;
+}
+
+
+function providerDataHasPasswordField(
+  providerData: PossibleProviderData[keyof PossibleProviderData],
+): providerData is { hashedPassword: string } {
+  return 'hashedPassword' in providerData;
+}
+
+// PRIVATE API
+export function createInvalidCredentialsError(message?: string): HttpError {
+  return new HttpError(401, 'Invalid credentials', { message })
+}

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

@@ -0,0 +1,83 @@
+import { HttpError } from 'wasp/server';
+
+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)
+}

package/data/Generator/templates/sdk/wasp/client/auth/discord.ts

@@ -0,0 +1,2 @@
+// PUBLIC API
+export { signInUrl as discordSignInUrl } from '../../auth/helpers/Discord'

package/data/Generator/templates/sdk/wasp/client/auth/email.ts

@@ -0,0 +1,5 @@
+// PUBLIC API
+export { login } from '../../auth/email/actions/login'
+export { signup } from '../../auth/email/actions/signup'
+export { requestPasswordReset, resetPassword } from '../../auth/email/actions/passwordReset'
+export { verifyEmail } from '../../auth/email/actions/verifyEmail'

package/data/Generator/templates/sdk/wasp/client/auth/github.ts

@@ -0,0 +1,2 @@
+// PUBLIC API
+export { signInUrl as githubSignInUrl } from '../../auth/helpers/GitHub'

package/data/Generator/templates/sdk/wasp/client/auth/google.ts

@@ -0,0 +1,2 @@
+// PUBLIC API
+export { signInUrl as googleSignInUrl } from '../../auth/helpers/Google'

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

@@ -0,0 +1,29 @@
+{{={= =}=}}
+export * from './ui'
+{=# isEmailAuthEnabled =}
+export * from './email'
+{=/ isEmailAuthEnabled =}
+{=# isUsernameAndPasswordAuthEnabled =}
+export * from './username'
+{=/ isUsernameAndPasswordAuthEnabled =}
+{=# isSlackAuthEnabled =}
+export * from './slack'
+{=/ isSlackAuthEnabled =}
+{=# isDiscordAuthEnabled =}
+export * from './discord'
+{=/ isDiscordAuthEnabled =}
+{=# isGoogleAuthEnabled  =}
+export * from './google'
+{=/ isGoogleAuthEnabled =}
+{=# isKeycloakAuthEnabled  =}
+export * from './keycloak'
+{=/ isKeycloakAuthEnabled =}
+{=# isGitHubAuthEnabled =}
+export * from './github'
+{=/ isGitHubAuthEnabled =}
+export {
+  default as useAuth,
+  getMe,
+} from '../../auth/useAuth'
+
+export { default as logout } from '../../auth/logout'

package/data/Generator/templates/sdk/wasp/client/auth/keycloak.ts

@@ -0,0 +1,2 @@
+// PUBLIC API
+export { signInUrl as keycloakSignInUrl } from '../../auth/helpers/Keycloak'

package/data/Generator/templates/sdk/wasp/client/auth/slack.ts

@@ -0,0 +1,2 @@
+// PUBLIC API
+export { signInUrl as slackSignInUrl } from '../../auth/helpers/Slack'

package/data/Generator/templates/sdk/wasp/client/auth/ui.ts

@@ -0,0 +1,32 @@
+{{={= =}=}}
+// PUBLIC API
+export { LoginForm } from '../../auth/forms/Login'
+export { SignupForm } from '../../auth/forms/Signup'
+{=# isEmailAuthEnabled =}
+export { ForgotPasswordForm } from '../../auth/forms/ForgotPassword'
+export { VerifyEmailForm } from '../../auth/forms/VerifyEmail'
+export { ResetPasswordForm } from '../../auth/forms/ResetPassword'
+{=/ isEmailAuthEnabled =}
+export type { CustomizationOptions } from '../../auth/forms/types'
+{=# isSlackAuthEnabled =}
+export { SignInButton as SlackSignInButton } from '../../auth/helpers/Slack'
+{=/ isSlackAuthEnabled =}
+{=# isDiscordAuthEnabled =}
+export { SignInButton as DiscordSignInButton } from '../../auth/helpers/Discord'
+{=/ isDiscordAuthEnabled =}
+{=# isGoogleAuthEnabled =}
+export { SignInButton as GoogleSignInButton } from '../../auth/helpers/Google'
+{=/ isGoogleAuthEnabled =}
+{=# isKeycloakAuthEnabled =}
+export { SignInButton as KeycloakSignInButton } from '../../auth/helpers/Keycloak'
+{=/ isKeycloakAuthEnabled =}
+{=# isGitHubAuthEnabled =}
+export { SignInButton as GitHubSignInButton } from '../../auth/helpers/GitHub'
+{=/ isGitHubAuthEnabled =}
+export {
+  FormError,
+  FormInput,
+  FormTextarea,
+  FormItemGroup,
+  FormLabel,
+} from '../../auth/forms/internal/Form'

package/data/Generator/templates/sdk/wasp/client/auth/username.ts

@@ -0,0 +1,2 @@
+export { login, signup } from '../../auth/username'
+

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

@@ -0,0 +1,15 @@
+{{={= =}=}}
+import { stripTrailingSlash } from '../universal/url.js'
+import { env } from './env.js'
+
+const apiUrl = stripTrailingSlash(env["{= serverUrlEnvVarName =}"])
+
+// PUBLIC API
+export type ClientConfig = {
+  apiUrl: string,
+}
+
+// PUBLIC API
+export const config: ClientConfig = {
+  apiUrl,
+}

package/data/Generator/templates/sdk/wasp/client/crud/_crud.ts

@@ -0,0 +1,89 @@
+{{={= =}=}}
+import { createAction } from "../operations/actions/core.js";
+import { createQuery } from "../operations/queries/core.js";
+import { makeUseActionFor, makeUseQueryFor } from "./operationsHelpers.js";
+import { 
+    {=# operations.Get =}
+    GetQueryResolved,
+    {=/ operations.Get =}
+    {=# operations.GetAll =}
+    GetAllQueryResolved,
+    {=/ operations.GetAll =}
+    {=# operations.Create =}
+    CreateActionResolved,
+    {=/ operations.Create =}
+    {=# operations.Update =}
+    UpdateActionResolved,
+    {=/ operations.Update =}
+    {=# operations.Delete =}
+    DeleteActionResolved,
+    {=/ operations.Delete =}
+} from 'wasp/server/crud/{= name =}'
+
+function createCrud() {
+    {=# operations.Get =}
+    const crudGetQuery = createQuery<GetQueryResolved>(
+        '{= fullPath =}',
+        {=& entitiesArray =}
+    )
+    {=/ operations.Get =}
+    {=# operations.GetAll =}
+    const crudGetAllQuery = createQuery<GetAllQueryResolved>(
+        '{= fullPath =}',
+        {=& entitiesArray =}
+    )
+    {=/ operations.GetAll =}
+    {=# operations.Create =}
+    const crudCreateAction = createAction<CreateActionResolved>(
+        '{= fullPath =}',
+        {=& entitiesArray =}
+    )
+    {=/ operations.Create =}
+    {=# operations.Update =}
+    const crudUpdateAction = createAction<UpdateActionResolved>(
+        '{= fullPath =}',
+        {=& entitiesArray =}
+    )
+    {=/ operations.Update =}
+    {=# operations.Delete =}
+    const crudDeleteAction = createAction<DeleteActionResolved>(
+        '{= fullPath =}',
+        {=& entitiesArray =}
+    )
+    {=/ operations.Delete =}
+    return {
+        {=# operations.Get =}
+        get: {
+            query: crudGetQuery,
+            useQuery: makeUseQueryFor(crudGetQuery)
+        },
+        {=/ operations.Get =}
+        {=# operations.GetAll =}
+        getAll: {
+            query: crudGetAllQuery,
+            useQuery: makeUseQueryFor(crudGetAllQuery)
+        },
+        {=/ operations.GetAll =}
+        {=# operations.Create =}
+        create: {
+            action: crudCreateAction,
+            useAction: makeUseActionFor(crudCreateAction)
+        },
+        {=/ operations.Create =}
+        {=# operations.Update =}
+        update: {
+            action: crudUpdateAction,
+            useAction: makeUseActionFor(crudUpdateAction)
+        },
+        {=/ operations.Update =}
+        {=# operations.Delete =}
+        delete: {
+            action: crudDeleteAction,
+            useAction: makeUseActionFor(crudDeleteAction)
+        },
+        {=/ operations.Delete =}
+    }
+}
+
+// PUBLIC API
+export const {= name =} = createCrud();

package/data/Generator/templates/sdk/wasp/client/crud/index.ts

@@ -0,0 +1,4 @@
+{{={= =}=}}
+{=# cruds =}
+  export { {= name =} } from './{= name =}';
+{=/ cruds =}