@wasp.sh/wasp-cli-darwin-arm64-unknown 0.17.2

package/data/Generator/templates/sdk/wasp/server/_types/taggedEntities.ts

@@ -0,0 +1,26 @@
+{{={= =}=}}
+// Wasp internally uses the types defined in this file for typing entity maps in
+// operation contexts.
+//
+// We must explicitly tag all entities with their name to avoid issues with
+// structural typing. See https://github.com/wasp-lang/wasp/pull/982 for details.
+import { 
+  type Entity, 
+  type EntityName,
+  {=# entities =}
+  type {= name =},
+  {=/ entities =}
+} from 'wasp/entities'
+
+{=# entities =}
+export type {= internalTypeName =} = WithName<{= name =}, "{= name =}">
+{=/ entities =}
+
+export type _Entity = 
+  {=# entities =}
+  | {= internalTypeName =}
+  {=/ entities =}
+  | never
+
+type WithName<E extends Entity, Name extends EntityName> = 
+  E & { _entityName: Name }

package/data/Generator/templates/sdk/wasp/server/api/index.ts

@@ -0,0 +1,44 @@
+{{={= =}=}}
+
+import { type ParamsDictionary as ExpressParams, type Query as ExpressQuery } from 'express-serve-static-core'
+
+import {
+  {=# allEntities =}
+  type {= internalTypeName =},
+  {=/ allEntities =}
+  {=# shouldImportNonAuthenticatedApi =}
+  type Api,
+  {=/ shouldImportNonAuthenticatedApi =}
+  {=# shouldImportAuthenticatedApi =}
+  type AuthenticatedApi,
+  {=/ shouldImportAuthenticatedApi =}
+} from '../_types'
+
+
+// PUBLIC API
+{=# apiRoutes =}
+export type {= typeName =}<
+  P extends ExpressParams = ExpressParams,
+  ResBody = any,
+  ReqBody = any,
+  ReqQuery extends ExpressQuery = ExpressQuery,
+  Locals extends Record<string, any> = Record<string, any>
+> =
+  {=# usesAuth =}
+  AuthenticatedApi<
+  {=/ usesAuth =}
+  {=^ usesAuth =}
+  Api<
+  {=/ usesAuth =}
+    [
+    {=# entities =}
+      {= internalTypeName =},
+    {=/ entities =}
+    ],
+    P,
+    ResBody,
+    ReqBody,
+    ReqQuery,
+    Locals
+  >
+{=/ apiRoutes =}

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

@@ -0,0 +1,20 @@
+// PUBLIC API
+export type GetVerificationEmailContentFn = (params: { verificationLink: string }) => EmailContent;
+
+// PUBLIC API
+export type GetPasswordResetEmailContentFn = (params: { passwordResetLink: string }) => EmailContent;
+
+type EmailContent = {
+    subject: string;
+    html: string;
+    text: string;
+}
+
+export {
+    createEmailVerificationLink,
+    sendEmailVerificationEmail,
+    createPasswordResetLink,
+    sendPasswordResetEmail,
+    isEmailResendAllowed,
+} from './utils.js'
+export { ensureValidEmail } from '../../../auth/validation.js'

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

@@ -0,0 +1,104 @@
+{{={= =}=}}
+import { createJWT, TimeSpan } from 'wasp/auth/jwt'
+import { emailSender } from 'wasp/server/email';
+import { Email } from 'wasp/server/email/core/types';
+import {
+  createProviderId,
+  updateAuthIdentityProviderData,
+  findAuthIdentity,
+  getProviderDataWithPassword,
+  type EmailProviderData,
+} from 'wasp/auth/utils';
+import { config as waspServerConfig } from 'wasp/server';
+import { type {= userEntityUpper =}, type {= authEntityUpper =} } from 'wasp/entities'
+
+// PUBLIC API
+export async function createEmailVerificationLink(
+  email: string,
+  clientRoute: string,
+): Promise<string> {
+  const { jwtToken } = await createEmailJWT(email);
+  return `${waspServerConfig.frontendUrl}${clientRoute}?token=${jwtToken}`;
+}
+
+// PUBLIC API
+export async function createPasswordResetLink(
+  email: string,
+  clientRoute: string,
+): Promise<string>  {
+  const { jwtToken } = await createEmailJWT(email);
+  return `${waspServerConfig.frontendUrl}${clientRoute}?token=${jwtToken}`;
+}
+
+async function createEmailJWT(email: string): Promise<{ jwtToken: string; }> {
+  const jwtToken = await createJWT({ email }, { expiresIn: new TimeSpan(30, "m") });
+  return { jwtToken };
+}
+
+// PUBLIC API
+export async function sendPasswordResetEmail(
+  email: string,
+  content: Email,
+): Promise<void> {
+  return sendEmailAndSaveMetadata(email, content, {
+    passwordResetSentAt: (new Date()).toISOString(),
+  });
+}
+
+// PUBLIC API
+export async function sendEmailVerificationEmail(
+  email: string,
+  content: Email,
+): Promise<void> {
+  return sendEmailAndSaveMetadata(email, content, {
+    emailVerificationSentAt: (new Date()).toISOString(),
+  });
+}
+
+async function sendEmailAndSaveMetadata(
+  email: string,
+  content: Email,
+  metadata: Partial<EmailProviderData>,
+): Promise<void> {
+  // Save the metadata (e.g. timestamp) first, and then send the email
+  // so the user can't send multiple requests while the email is being sent.
+  const providerId = createProviderId("email", email);
+  const authIdentity = await findAuthIdentity(providerId);
+
+  if (!authIdentity) {
+    throw new Error(`User with email: ${email} not found.`);
+  }
+
+  const providerData = getProviderDataWithPassword<'email'>(authIdentity.providerData);
+  await updateAuthIdentityProviderData<'email'>(providerId, providerData, metadata);
+
+  emailSender.send(content).catch((e) => {
+    console.error('Failed to send email', e);
+  });
+}
+
+// PUBLIC API
+export function isEmailResendAllowed<Field extends 'emailVerificationSentAt' | 'passwordResetSentAt'>(
+  fields: {
+    [field in Field]: string | null
+  },
+  field: Field,
+  resendInterval: number = 1000 * 60,
+): {
+  isResendAllowed: boolean;
+  timeLeft: number;
+} {
+  const sentAt = fields[field];
+  if (!sentAt) {
+    return {
+      isResendAllowed: true,
+      timeLeft: 0,
+    };
+  }
+  const now = new Date();
+  const diff = now.getTime() - new Date(sentAt).getTime();
+  const isResendAllowed = diff > resendInterval;
+  // Time left in seconds
+  const timeLeft = isResendAllowed ? 0 : Math.round((resendInterval - diff) / 1000);
+  return { isResendAllowed, timeLeft };
+}

package/data/Generator/templates/sdk/wasp/server/auth/hooks.ts

@@ -0,0 +1,188 @@
+{{={= =}=}}
+import type { Request as ExpressRequest } from 'express'
+import { type ProviderId, type CreateUserResult, type FindAuthWithUserResult } from '../../auth/utils.js'
+import { prisma } from '../index.js'
+import { Expand } from '../../universal/types.js'
+
+// PUBLIC API
+export type OnBeforeSignupHook = (
+  params: Expand<OnBeforeSignupHookParams>,
+) => void | Promise<void>
+
+// PUBLIC API
+export type OnAfterSignupHook = (
+  params: Expand<OnAfterSignupHookParams>,
+) => void | Promise<void>
+
+// PUBLIC API
+/**
+ * Use this type for typing your `onAfterEmailVerified` hook.
+ * 
+ * Wasp calls this hook exactly once, after a user successfully verifies their email during the email verification flow.
+ * 
+ * @example
+ * ```ts
+ * export const onAfterEmailVerified: OnAfterEmailVerifiedHook = async ({
+ *   email,
+ * }) => {
+ *   await emailSender.send({
+ *     to: email,
+ *     subject: 'Welcome to our platform!',
+ *     text: `Your email ${email} has been verified successfully.`
+ *   })
+ * }
+ * ```
+ */
+export type OnAfterEmailVerifiedHook = (
+  params: Expand<OnAfterEmailVerifiedHookParams>,
+) => void | Promise<void>
+
+// PUBLIC API
+/**
+ * @returns Object with a URL that the OAuth flow should redirect to.
+ */
+export type OnBeforeOAuthRedirectHook = (
+  params: Expand<OnBeforeOAuthRedirectHookParams>,
+) => { url: URL } | Promise<{ url: URL }>
+
+// PUBLIC API
+export type OnBeforeLoginHook = (
+  params: Expand<OnBeforeLoginHookParams>,
+) => void | Promise<void>
+
+// PUBLIC API
+export type OnAfterLoginHook = (
+  params: Expand<OnAfterLoginHookParams>,
+) => void | Promise<void>
+
+// PRIVATE API (used in the SDK and the server)
+export type InternalAuthHookParams = {
+  /**
+   * Prisma instance that can be used to interact with the database.
+  */
+  prisma: typeof prisma
+}
+
+// NOTE: We should be exporting types that can be reached by users via other
+// exported types (e.g. using the Parameters<T> Typescript helper).
+// However, we are not exporting this type to keep the API surface smaller.
+// This type is only used internally by the SDK. Exporting it might confuse
+// users since the name is too similar to the exported function type.
+// Same goes for all other *Params types in this file.
+type OnBeforeSignupHookParams = {
+  /**
+   * Provider ID object that contains the provider name and the provider user ID.
+  */
+  providerId: ProviderId
+  /**
+   * Request object that can be used to access the user's incoming signup request.
+  */
+  req: ExpressRequest
+} & InternalAuthHookParams
+
+type OnAfterSignupHookParams = {
+  /**
+   * Provider ID object that contains the provider name and the provider user ID.
+  */
+  providerId: ProviderId
+  /**
+   * User object that was created during the signup process.
+  */
+  user: CreateUserResult
+  /**
+   * OAuth flow data that was generated during the OAuth flow. This is only
+   * available if the user signed up using OAuth.
+  */
+  oauth?: OAuthData
+  /**
+   * Request object that can be used to access the user's incoming signup request.
+  */
+  req: ExpressRequest
+} & InternalAuthHookParams
+
+type OnAfterEmailVerifiedHookParams = {
+  /**
+   * The email address that was verified.
+  */
+  email: string
+  /**
+   * The user who completed email verification.
+  */
+  user: FindAuthWithUserResult['user']
+  /**
+   * Request object that can be used to access the user's incoming verification request.
+   */
+  req: ExpressRequest
+} & InternalAuthHookParams
+
+type OnBeforeOAuthRedirectHookParams = {
+  /**
+   * URL that the OAuth flow should redirect to.
+  */
+  url: URL
+  /**
+   * Unique request ID that was generated during the OAuth flow.
+  */
+  oauth: Pick<OAuthData, 'uniqueRequestId'>
+  /**
+   * Request object that can be used to access the user's incoming OAuth flow request.
+  */
+  req: ExpressRequest
+} & InternalAuthHookParams
+
+type OnBeforeLoginHookParams = {
+  /**
+   * Provider ID object that contains the provider name and the provider user ID.
+  */
+  providerId: ProviderId
+  /**
+   * User that is trying to log in.
+  */
+  user: FindAuthWithUserResult['user']
+  /**
+   * Request object that can be used to access the user's incoming login request.
+  */
+  req: ExpressRequest
+} & InternalAuthHookParams
+
+type OnAfterLoginHookParams = {
+  /**
+   * Provider ID object that contains the provider name and the provider user ID.
+  */
+  providerId: ProviderId
+  /**
+   * User that is logged in.
+  */
+  user: FindAuthWithUserResult['user']
+  /**
+   * OAuth flow data that was generated during the OAuth flow. This is only
+   * available if the user logged in using OAuth.
+  */
+  oauth?: OAuthData
+  /**
+   * Request object that can be used to access the user's incoming login request.
+  */
+  req: ExpressRequest
+} & InternalAuthHookParams
+
+// PUBLIC API
+export type OAuthData = {
+  /**
+   * Unique request ID that was generated during the OAuth flow.
+  */
+  uniqueRequestId: string
+} & (
+  {=# enabledProviders.isGoogleAuthEnabled =}
+  | { providerName: 'google'; tokens: import('arctic').GoogleTokens } 
+  {=/ enabledProviders.isGoogleAuthEnabled =}
+  {=# enabledProviders.isDiscordAuthEnabled =}
+  | { providerName: 'discord'; tokens: import('arctic').DiscordTokens }
+  {=/ enabledProviders.isDiscordAuthEnabled =}
+  {=# enabledProviders.isGitHubAuthEnabled =}
+  | { providerName: 'github'; tokens: import('arctic').GitHubTokens }
+  {=/ enabledProviders.isGitHubAuthEnabled =}
+  {=# enabledProviders.isKeycloakAuthEnabled =}
+  | { providerName: 'keycloak'; tokens: import('arctic').KeycloakTokens }
+  {=/ enabledProviders.isKeycloakAuthEnabled =}
+  | never
+)

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

@@ -0,0 +1,49 @@
+{{={= =}=}}
+export {
+  defineUserSignupFields,
+} from '../../auth/providers/types.js'
+
+export {
+  createProviderId,
+  sanitizeAndSerializeProviderData,
+  updateAuthIdentityProviderData,
+  getProviderData,
+  getProviderDataWithPassword,
+  findAuthIdentity,
+  createUser,
+  type CreateUserResult,
+  type ProviderId,
+  type ProviderName,
+  type EmailProviderData,
+  type UsernameProviderData,
+  type OAuthProviderData,
+} from '../../auth/utils.js'
+
+export {
+  ensurePasswordIsPresent,
+  ensureValidPassword,
+  ensureTokenIsPresent,
+} from '../../auth/validation.js'
+
+export type {
+  OnBeforeSignupHook,
+  OnAfterSignupHook,
+  OnAfterEmailVerifiedHook,
+  OnBeforeOAuthRedirectHook,
+  OnBeforeLoginHook,
+  OnAfterLoginHook,
+  InternalAuthHookParams,
+  OAuthData,
+} from './hooks.js'
+
+{=# isExternalAuthEnabled =}
+export * from './oauth/index.js'
+{=/ isExternalAuthEnabled =}
+
+{=# enabledProviders.isEmailAuthEnabled =}
+export * from './email/index.js'
+{=/ enabledProviders.isEmailAuthEnabled =}
+
+{=# enabledProviders.isUsernameAndPasswordAuthEnabled =}
+export * from './username.js'
+{=/ enabledProviders.isUsernameAndPasswordAuthEnabled =}

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

@@ -0,0 +1,38 @@
+{{={= =}=}}
+{=# enabledProviders.isGoogleAuthEnabled =}
+// PUBLIC API
+export { google } from './providers/google.js';
+{=/ enabledProviders.isGoogleAuthEnabled =}
+
+{=# enabledProviders.isSlackAuthEnabled =}
+// PUBLIC API
+export { slack } from './providers/slack.js';
+{=/ enabledProviders.isSlackAuthEnabled =}
+
+{=# enabledProviders.isDiscordAuthEnabled =}
+// PUBLIC API
+export { discord } from './providers/discord.js';
+{=/ enabledProviders.isDiscordAuthEnabled =}
+
+{=# enabledProviders.isGitHubAuthEnabled =}
+// PUBLIC API
+export { github } from './providers/github.js';
+{=/ enabledProviders.isGitHubAuthEnabled =}
+{=# enabledProviders.isKeycloakAuthEnabled =}
+// PUBLIC API
+export { keycloak } from './providers/keycloak.js';
+{=/ enabledProviders.isKeycloakAuthEnabled =}
+
+// PRIVATE API
+export {
+  loginPath,
+  callbackPath,
+  exchangeCodeForTokenPath,
+  handleOAuthErrorAndGetRedirectUri,
+  getRedirectUriForOneTimeCode,
+} from './redirect.js'
+
+// PRIVATE API
+export {
+  tokenStore,
+} from './oneTimeCode.js'

package/data/Generator/templates/sdk/wasp/server/auth/oauth/oneTimeCode.ts

@@ -0,0 +1,50 @@
+import { createJWT, validateJWT, TimeSpan } from '../../../auth/jwt.js'
+
+export const tokenStore = createTokenStore();
+
+function createTokenStore() {
+  const usedTokens = new Map<string, number>();
+
+  const validFor = new TimeSpan(1, 'm') // 1 minute
+  const cleanupAfter = 1000 * 60 * 60; // 1 hour
+
+  function createToken(userId: string): Promise<string> {
+    return createJWT(
+      {
+        id: userId,
+      },
+      {
+        expiresIn: validFor,
+      }
+    );
+  }
+
+  function verifyToken(token: string): Promise<{ id: string }> {
+    return validateJWT(token);
+  }
+
+  function isUsed(token: string): boolean {
+    return usedTokens.has(token);
+  }
+
+  function markUsed(token: string): void {
+    usedTokens.set(token, Date.now());
+    cleanUp();
+  }
+
+  function cleanUp(): void {
+    const now = Date.now();
+    for (const [token, timestamp] of usedTokens.entries()) {
+      if (now - timestamp > cleanupAfter) {
+        usedTokens.delete(token);
+      }
+    }
+  }
+
+  return {
+    createToken,
+    verifyToken,
+    isUsed,
+    markUsed,
+  };
+}

package/data/Generator/templates/sdk/wasp/server/auth/oauth/provider.ts

@@ -0,0 +1,20 @@
+import { OAuth2Provider, OAuth2ProviderWithPKCE } from "arctic";
+
+export function defineProvider<
+  OAuthClient extends OAuth2Provider | OAuth2ProviderWithPKCE,
+  const Id extends string
+>({
+  id,
+  displayName,
+  oAuthClient,
+}: {
+  id: Id;
+  displayName: string;
+  oAuthClient: OAuthClient;
+}) {
+  return {
+    id,
+    displayName,
+    oAuthClient,
+  };
+}

package/data/Generator/templates/sdk/wasp/server/auth/oauth/providers/discord.ts

@@ -0,0 +1,22 @@
+{{={= =}=}}
+import { Discord  } from 'arctic';
+
+import { defineProvider } from '../provider.js';
+import { getRedirectUriForCallback } from '../redirect.js';
+import { env } from '../../../env.js';
+
+const id = '{= providerId =}';
+const displayName = '{= displayName =}';
+
+const oAuthClient = new Discord(
+  env.DISCORD_CLIENT_ID,
+  env.DISCORD_CLIENT_SECRET,
+  getRedirectUriForCallback(id).toString(),
+);
+
+// PUBLIC API
+export const discord = defineProvider({
+  id,
+  displayName,
+  oAuthClient,
+});

package/data/Generator/templates/sdk/wasp/server/auth/oauth/providers/github.ts

@@ -0,0 +1,20 @@
+{{={= =}=}}
+import { GitHub  } from 'arctic';
+
+import { defineProvider } from '../provider.js';
+import { env } from '../../../env.js';
+
+const id = '{= providerId =}';
+const displayName = '{= displayName =}';
+
+const oAuthClient = new GitHub(
+  env.GITHUB_CLIENT_ID,
+  env.GITHUB_CLIENT_SECRET,
+);
+
+// PUBLIC API
+export const github = defineProvider({
+  id,
+  displayName,
+  oAuthClient,
+});

package/data/Generator/templates/sdk/wasp/server/auth/oauth/providers/google.ts

@@ -0,0 +1,22 @@
+{{={= =}=}}
+import { Google  } from 'arctic';
+
+import { getRedirectUriForCallback } from '../redirect.js';
+import { defineProvider } from '../provider.js';
+import { env } from '../../../env.js';
+
+const id = '{= providerId =}';
+const displayName = '{= displayName =}';
+
+const oAuthClient = new Google(
+  env.GOOGLE_CLIENT_ID,
+  env.GOOGLE_CLIENT_SECRET,
+  getRedirectUriForCallback(id).toString(),
+);
+
+// PUBLIC API
+export const google = defineProvider({
+  id,
+  displayName,
+  oAuthClient,
+});

package/data/Generator/templates/sdk/wasp/server/auth/oauth/providers/keycloak.ts

@@ -0,0 +1,23 @@
+{{={= =}=}}
+import { Keycloak  } from 'arctic';
+
+import { getRedirectUriForCallback } from '../redirect.js';
+import { defineProvider } from '../provider.js';
+import { env } from '../../../env.js';
+
+const id = '{= providerId =}';
+const displayName = '{= displayName =}';
+
+const oAuthClient = new Keycloak(
+  env.KEYCLOAK_REALM_URL,
+  env.KEYCLOAK_CLIENT_ID,
+  env.KEYCLOAK_CLIENT_SECRET,
+  getRedirectUriForCallback(id).toString(),
+);
+
+// PUBLIC API
+export const keycloak = defineProvider({
+  id,
+  displayName,
+  oAuthClient,
+});

package/data/Generator/templates/sdk/wasp/server/auth/oauth/providers/slack.ts

@@ -0,0 +1,22 @@
+{{={= =}=}}
+import { Slack } from 'arctic';
+
+import { defineProvider } from '../provider.js';
+import { getRedirectUriForCallback } from '../redirect.js';
+import { env } from '../../../env.js';
+
+const id = '{= providerId =}';
+const displayName = '{= displayName =}';
+
+const oAuthClient = new Slack(
+  env.SLACK_CLIENT_ID,
+  env.SLACK_CLIENT_SECRET,
+  getRedirectUriForCallback(id).toString(),
+);
+
+// PUBLIC API
+export const slack = defineProvider({
+  id,
+  displayName,
+  oAuthClient,
+});