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

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

@@ -0,0 +1,43 @@
+{{={= =}=}}
+import { config, HttpError } from '../../index.js'
+
+// PRIVATE API (server)
+export const loginPath = '{= serverOAuthLoginHandlerPath =}'
+
+// PRIVATE API (server)
+export const exchangeCodeForTokenPath = '{= serverExchangeCodeForTokenHandlerPath =}'
+
+// PRIVATE API (server)
+export const callbackPath = '{= serverOAuthCallbackHandlerPath =}'
+
+const clientOAuthCallbackPath = '{= clientOAuthCallbackPath =}'
+
+// PRIVATE API (server)
+export function getRedirectUriForOneTimeCode(oneTimeCode: string): URL {
+  return new URL(`${config.frontendUrl}${clientOAuthCallbackPath}#${oneTimeCode}`);
+}
+
+// PRIVATE API (server)
+export function handleOAuthErrorAndGetRedirectUri(error: unknown): URL {
+  if (error instanceof HttpError) {
+    const errorMessage = isHttpErrorWithExtraMessage(error)
+      ? `${error.message}: ${error.data.message}`
+      : error.message;
+    return getRedirectUriForError(errorMessage)
+  }
+  console.error("Unknown OAuth error:", error);
+  return getRedirectUriForError("An unknown error occurred while trying to log in with the OAuth provider.");
+}
+
+// PRIVATE API (SDK)
+export function getRedirectUriForCallback(providerName: string): URL {
+  return new URL(`${config.serverUrl}/auth/${providerName}/${callbackPath}`);
+}
+
+function getRedirectUriForError(error: string): URL {
+  return new URL(`${config.frontendUrl}${clientOAuthCallbackPath}?error=${error}`);
+}
+
+function isHttpErrorWithExtraMessage(error: HttpError): error is HttpError & { data: { message: string } } {
+  return !!error.data && typeof (error.data as any).message === 'string';
+}

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

@@ -0,0 +1,148 @@
+{{={= =}=}}
+import {
+  type {= userEntityName =},
+  type {= authEntityName =},
+  type {= authIdentityEntityName =},
+} from '../../entities/index.js'
+import {
+  type PossibleProviderData,
+  getProviderData,
+} from '../../auth/utils.js'
+import { type ProviderName } from '../_types/index.js'
+import { Expand } from '../../universal/types.js'
+
+// PUBLIC API
+export type AuthUser = AuthUserData & {
+  getFirstProviderUserId: () => string | null,
+}
+
+// PRIVATE API
+/*
+ * Ideally, we'd do something like this:
+ * ```
+ * export type AuthUserData = ReturnType<typeof createAuthUserData>
+ * ```
+ * to get the benefits of the createAuthUser and the AuthUserData type being in sync.
+ * 
+ * But since we are not using strict mode, the inferred return type of createAuthUser
+ * is not correct. So we have to define the AuthUserData type manually.
+ * 
+ * TODO: Change this once/if we switch to strict mode. https://github.com/wasp-lang/wasp/issues/1938
+ */
+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 =}
+  },
+}
+
+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
+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 =}
+  }
+  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
+}

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

@@ -0,0 +1 @@
+export { ensureValidUsername } from '../../auth/validation.js'

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

@@ -0,0 +1,47 @@
+{{={= =}=}}
+import { env } from './env.js'
+import { stripTrailingSlash, getOrigin } from '../universal/url.js'
+
+type NodeEnv = typeof env.NODE_ENV
+
+type Config = {
+  env: NodeEnv;
+  isDevelopment: boolean;
+  port: number;
+  databaseUrl: string;
+  frontendUrl: string;
+  serverUrl: string;
+  allowedCORSOrigins: (string | RegExp)[];
+  {=# isAuthEnabled =}
+  auth: {
+    jwtSecret: string;
+  }
+  {=/ isAuthEnabled =}
+}
+
+const frontendUrl = stripTrailingSlash(env['{= clientUrlEnvVarName =}'])
+const serverUrl = stripTrailingSlash(env['{= serverUrlEnvVarName =}'])
+
+const allowedCORSOriginsPerEnv: Record<NodeEnv, Config['allowedCORSOrigins']> = {
+  development: [/.*/],
+  production: [getOrigin(frontendUrl)]
+}
+const allowedCORSOrigins = allowedCORSOriginsPerEnv[env.NODE_ENV]
+
+const config: Config = {
+  frontendUrl,
+  serverUrl,
+  allowedCORSOrigins,
+  env: env.NODE_ENV,
+  isDevelopment: env.NODE_ENV === 'development',
+  port: env.PORT,
+  databaseUrl: env.{= databaseUrlEnvVarName =},
+  {=# isAuthEnabled =}
+  auth: {
+    jwtSecret: env["{= jwtSecretEnvVarName =}"]
+  }
+  {=/ isAuthEnabled =}
+}
+
+// PUBLIC API
+export default config

package/data/Generator/templates/sdk/wasp/server/crud/_operationTypes.ts

@@ -0,0 +1,134 @@
+{{={= =}=}}
+import type {
+  {=# isAuthEnabled =}
+  AuthenticatedActionDefinition,
+  AuthenticatedQueryDefinition,
+  {=/ isAuthEnabled =}
+  {=^ isAuthEnabled =}
+  UnauthenticatedActionDefinition,
+  UnauthenticatedQueryDefinition,
+  {=/ isAuthEnabled =}
+  _{= crud.entityUpper =},
+} from "../_types";
+import type { Prisma } from "@prisma/client";
+import type { Payload, SuperJSONObject } from "wasp/core/serialization";
+import type {
+  {= crud.entityUpper =},
+} from "wasp/entities";
+{=# overrides.GetAll.isDefined =}
+{=& overrides.GetAll.importStatement =}
+{=/ overrides.GetAll.isDefined =}
+{=# overrides.Get.isDefined =}
+{=& overrides.Get.importStatement =}
+{=/ overrides.Get.isDefined =}
+{=# overrides.Create.isDefined =}
+{=& overrides.Create.importStatement =}
+{=/ overrides.Create.isDefined =}
+{=# overrides.Update.isDefined =}
+{=& overrides.Update.importStatement =}
+{=/ overrides.Update.isDefined =}
+{=# overrides.Delete.isDefined =}
+{=& overrides.Delete.importStatement =}
+{=/ overrides.Delete.isDefined =}
+
+type _WaspEntityTagged = _{= crud.entityUpper =}
+type _WaspEntity = {= crud.entityUpper =}
+
+/**
+ * PUBLIC API
+ */
+export declare namespace {= crud.name =} {
+  {=# crud.operations.GetAll =}
+  export type GetAllQuery<Input extends Payload = never, Output extends Payload = Payload> = {= queryType =}<[_WaspEntityTagged], Input, Output>
+  {=/ crud.operations.GetAll =}
+
+  {=# crud.operations.Get =}
+  export type GetQuery<Input extends Payload = never, Output extends Payload = Payload> = {= queryType =}<[_WaspEntityTagged], Input, Output>
+  {=/ crud.operations.Get =}
+
+  {=# crud.operations.Create =}
+  export type CreateAction<Input extends Payload = never, Output extends Payload = Payload> = {= actionType =}<[_WaspEntityTagged], Input, Output>
+  {=/ crud.operations.Create =}
+
+  {=# crud.operations.Update =}
+  export type UpdateAction<Input extends Payload = never, Output extends Payload = Payload> = {= actionType =}<[_WaspEntityTagged], Input, Output>
+  {=/ crud.operations.Update =}
+
+  {=# crud.operations.Delete =}
+  export type DeleteAction<Input extends Payload = never, Output extends Payload = Payload> = {= actionType =}<[_WaspEntityTagged], Input, Output>
+  {=/ crud.operations.Delete =}
+}
+
+/**
+ * PRIVATE API
+ *
+ * The types with the `Resolved` suffix are the types that are used internally by the Wasp client
+ * to implement full-stack type safety.
+ */
+{=# crud.operations.GetAll =}
+{=^ overrides.GetAll.isDefined =}
+type GetAllInput = {}
+type GetAllOutput = _WaspEntity[]
+export type GetAllQueryResolved = {= crud.name =}.GetAllQuery<GetAllInput, GetAllOutput>
+{=/ overrides.GetAll.isDefined =}
+{=# overrides.GetAll.isDefined =}
+const _waspGetAllQuery = {= overrides.GetAll.importIdentifier =}
+export type GetAllQueryResolved = typeof _waspGetAllQuery
+{=/ overrides.GetAll.isDefined =}
+{=/ crud.operations.GetAll =}
+
+{=# crud.operations.Get =}
+{=^ overrides.Get.isDefined =}
+type GetInput = SuperJSONObject & Prisma.{= crud.entityUpper =}WhereUniqueInput
+type GetOutput = _WaspEntity | null
+export type GetQueryResolved = {= crud.name =}.GetQuery<GetInput, GetOutput>
+{=/ overrides.Get.isDefined =}
+{=# overrides.Get.isDefined =}
+const _waspGetQuery = {= overrides.Get.importIdentifier =}
+export type GetQueryResolved = typeof _waspGetQuery
+{=/ overrides.Get.isDefined =}
+{=/ crud.operations.Get =}
+
+{=# crud.operations.Create =}
+{=^ overrides.Create.isDefined =}
+type CreateInput = SuperJSONObject & Prisma.XOR<
+  Prisma.{= crud.entityUpper =}CreateInput,
+  Prisma.{= crud.entityUpper =}UncheckedCreateInput
+>
+type CreateOutput = _WaspEntity
+export type CreateActionResolved = {= crud.name =}.CreateAction<CreateInput, CreateOutput>
+{=/ overrides.Create.isDefined =}
+{=# overrides.Create.isDefined =}
+const _waspCreateAction = {= overrides.Create.importIdentifier =}
+export type CreateActionResolved = typeof _waspCreateAction
+{=/ overrides.Create.isDefined =}
+{=/ crud.operations.Create =}
+
+{=# crud.operations.Update =}
+{=^ overrides.Update.isDefined =}
+type UpdateInput = SuperJSONObject & Prisma.XOR<
+    Prisma.{= crud.entityUpper =}UpdateInput,
+    Prisma.{= crud.entityUpper =}UncheckedUpdateInput
+  >
+  & Prisma.{= crud.entityUpper =}WhereUniqueInput
+
+type UpdateOutput = _WaspEntity
+export type UpdateActionResolved = {= crud.name =}.UpdateAction<UpdateInput, UpdateOutput>
+{=/ overrides.Update.isDefined =}
+{=# overrides.Update.isDefined =}
+const _waspUpdateAction = {= overrides.Update.importIdentifier =}
+export type UpdateActionResolved = typeof _waspUpdateAction
+{=/ overrides.Update.isDefined =}
+{=/ crud.operations.Update =}
+
+{=# crud.operations.Delete =}
+{=^ overrides.Delete.isDefined =}
+type DeleteInput = SuperJSONObject & Prisma.{= crud.entityUpper =}WhereUniqueInput
+type DeleteOutput = _WaspEntity
+export type DeleteActionResolved = {= crud.name =}.DeleteAction<DeleteInput, DeleteOutput>
+{=/ overrides.Delete.isDefined =}
+{=# overrides.Delete.isDefined =}
+const _waspDeleteAction = {= overrides.Delete.importIdentifier =}
+export type DeleteActionResolved = typeof _waspDeleteAction
+{=/ overrides.Delete.isDefined =}
+{=/ crud.operations.Delete =}

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

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

package/data/Generator/templates/sdk/wasp/server/dbClient.ts

@@ -0,0 +1,35 @@
+{{={= =}=}}
+{=# areThereAnyEntitiesDefined =}
+{=# prismaSetupFn.isDefined =}
+{=& prismaSetupFn.importStatement =}
+
+function createDbClient() {
+  return {= prismaSetupFn.importIdentifier =}()
+}
+{=/ prismaSetupFn.isDefined =}
+{=^ prismaSetupFn.isDefined =}
+import { PrismaClient as InternalPrismaClient } from '@prisma/client'
+
+function createDbClient() {
+  return new InternalPrismaClient()
+}
+{=/ prismaSetupFn.isDefined =}
+{=/ areThereAnyEntitiesDefined =}
+{=^ areThereAnyEntitiesDefined =}
+// * Prisma will not generate a PrismaClient if there no
+//   entities in the schema. Trying to init the PrismaClient
+//   will throw an error.
+// * To avoid throwing an error, we return null if there are no
+//   entities in the schema.
+function createDbClient(): null {
+  return null
+}
+{=/ areThereAnyEntitiesDefined =}
+
+const dbClient = createDbClient()
+
+// PUBLIC API 
+export type PrismaClient = typeof dbClient
+
+// PUBLIC API
+export default dbClient

package/data/Generator/templates/sdk/wasp/server/email/core/helpers.ts

@@ -0,0 +1,40 @@
+{{={= =}=}}
+import { EmailFromField } from "./types";
+
+// PRIVATE API
+// Formats an email address and an optional name into a string that can be used
+// as the "from" field in an email.
+// { email: "test@test.com, name: "Test" } -> "Test <test@test.com>"
+export function formatFromField({
+  email,
+  name,
+}: {
+  email: string;
+  name?: string;
+}): string {
+  if (name) {
+    return `${name} <${email}>`;
+  }
+  return email;
+}
+
+{=# isDefaultFromFieldDefined =}
+// PRIVATE API
+export function getDefaultFromField(): EmailFromField {
+  return {
+    email: "{= defaultFromField.email =}",
+    {=# defaultFromField.isNameDefined =}
+    name: "{= defaultFromField.name =}",
+    {=/ defaultFromField.isNameDefined =}
+  }
+}
+{=/ isDefaultFromFieldDefined =}
+{=^ isDefaultFromFieldDefined =}
+// PRIVATE API
+export function getDefaultFromField(): EmailFromField {
+  return {
+    email: "",
+    name: "",
+  };
+}
+{=/ isDefaultFromFieldDefined =}

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

@@ -0,0 +1,17 @@
+{{={= =}=}}
+{=# isSmtpProviderEnabled =}
+// PRIVATE API
+export { initSmtpEmailSender as initEmailSender } from "./providers/smtp.js";
+{=/ isSmtpProviderEnabled =}
+{=# isSendGridProviderEnabled =}
+// PRIVATE API
+export { initSendGridEmailSender as initEmailSender } from "./providers/sendgrid.js";
+{=/ isSendGridProviderEnabled =}
+{=# isMailgunProviderEnabled =}
+// PRIVATE API
+export { initMailgunEmailSender as initEmailSender } from "./providers/mailgun.js";
+{=/ isMailgunProviderEnabled =}
+{=# isDummyProviderEnabled =}
+// PRIVATE API
+export { initDummyEmailSender as initEmailSender } from "./providers/dummy.js";
+{=/ isDummyProviderEnabled =}

package/data/Generator/templates/sdk/wasp/server/email/core/providers/dummy.ts

@@ -0,0 +1,34 @@
+import { DummyEmailProvider, EmailSender } from "../types";
+import { getDefaultFromField } from "../helpers.js";
+
+import { getColorizedConsoleFormatString } from 'wasp/universal/ansiColors'
+
+const yellowColorFormatString = getColorizedConsoleFormatString('yellow');
+
+// PRIVATE API
+export function initDummyEmailSender(
+    config?: DummyEmailProvider,
+): EmailSender {
+    const defaultFromField = getDefaultFromField();
+    return {
+        send: async (email) => {
+            const fromField = email.from || defaultFromField;
+
+            console.log(yellowColorFormatString, '╔═══════════════════════╗');
+            console.log(yellowColorFormatString, '║ Dummy email sender ✉️  ║');
+            console.log(yellowColorFormatString, '╚═══════════════════════╝');
+            console.log(`From:    ${fromField.name} <${fromField.email}>`);
+            console.log(`To:      ${email.to}`);
+            console.log(`Subject: ${email.subject}`);
+            console.log(yellowColorFormatString, '═════════ Text ═════════');
+            console.log(email.text);
+            console.log(yellowColorFormatString, '═════════ HTML ═════════');
+            console.log(email.html);
+            console.log(yellowColorFormatString, '════════════════════════');
+
+            return {
+                success: true,
+            };
+        }
+    }
+}

package/data/Generator/templates/sdk/wasp/server/email/core/providers/mailgun.ts

@@ -0,0 +1,31 @@
+import Mailgun from 'mailgun.js';
+import { getDefaultFromField } from "../helpers.js";
+import type { MailgunEmailProvider, EmailSender } from "../types";
+
+// PRIVATE API
+export function initMailgunEmailSender(
+  config: MailgunEmailProvider
+): EmailSender {
+  const defaultFromField = getDefaultFromField();
+
+  const mailgun = new Mailgun(FormData);
+
+  const mailer = mailgun.client({
+    username: 'api',
+    key: config.apiKey,
+    url: config.apiUrl,
+  });
+
+  return {
+    async send(email) {
+      const fromField = email.from || defaultFromField;
+      return mailer.messages.create(config.domain, {
+        from: `${fromField.name} <${fromField.email}>`,
+        to: [email.to],
+        subject: email.subject,
+        text: email.text,
+        html: email.html,
+      })
+    },
+  };
+}

package/data/Generator/templates/sdk/wasp/server/email/core/providers/sendgrid.ts

@@ -0,0 +1,44 @@
+import SendGrid from "@sendgrid/mail";
+import { getDefaultFromField } from "../helpers.js";
+import type { SendGridProvider, EmailSender } from "../types";
+
+// PRIVATE API
+export function initSendGridEmailSender(
+  provider: SendGridProvider
+): EmailSender {
+  SendGrid.setApiKey(provider.apiKey);
+
+  const defaultFromField = getDefaultFromField();
+
+  return {
+    async send(email) {
+      const fromField = email.from || defaultFromField;
+      return SendGrid.send({
+        from: {
+          email: fromField.email,
+          name: fromField.name,
+        },
+        to: email.to,
+        subject: email.subject,
+        text: email.text,
+        html: email.html,
+      }).catch((error) => {
+        // SendGrid can return an array of errors in its response,
+        // but the client doesn't surface them appropriately.
+        // If we find it, we will throw an AggregateError with all the errors
+        // so that they are all printed. Otherwise, we will throw the
+        // original error.
+
+        const responseErrors = error?.response?.body?.errors;
+        if (responseErrors && Array.isArray(responseErrors)) {
+          throw new AggregateError(
+            [...responseErrors, error],
+            `SendGrid error: ${error.message}`
+          );
+        } else {
+          throw error;
+        }
+      });
+    },
+  };
+}

package/data/Generator/templates/sdk/wasp/server/email/core/providers/smtp.ts

@@ -0,0 +1,29 @@
+import { createTransport } from "nodemailer";
+import { formatFromField, getDefaultFromField } from "../helpers.js";
+import type { SMTPEmailProvider, EmailSender } from "../types";
+
+// PRIVATE API
+export function initSmtpEmailSender(config: SMTPEmailProvider): EmailSender {
+  const transporter = createTransport({
+    host: config.host,
+    port: config.port,
+    auth: {
+      user: config.username,
+      pass: config.password,
+    },
+  });
+
+  const defaultFromField = getDefaultFromField();
+
+  return {
+    async send(email) {
+      return transporter.sendMail({
+        from: formatFromField(email.from || defaultFromField),
+        to: email.to,
+        subject: email.subject,
+        text: email.text,
+        html: email.html,
+      });
+    },
+  };
+}

package/data/Generator/templates/sdk/wasp/server/email/core/types.ts

@@ -0,0 +1,59 @@
+{{={= =}=}}
+// PRIVATE API
+export type EmailProvider = SMTPEmailProvider | SendGridProvider | MailgunEmailProvider | DummyEmailProvider;
+
+// PRIVATE API
+export type SMTPEmailProvider = {
+  type: "smtp";
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+};
+
+// PRIVATE API
+export type SendGridProvider = {
+  type: "sendgrid";
+  apiKey: string;
+};
+
+// PRIVATE API
+export type MailgunEmailProvider = {
+  type: "mailgun";
+  apiKey: string;
+  domain: string;
+  apiUrl?: string;
+};
+
+// PRIVATE API
+export type DummyEmailProvider = {
+  type: "dummy";
+}
+
+// PUBLIC API
+export type EmailSender = {
+  send: (email: Email) => Promise<SentMessageInfo>;
+};
+
+// PUBLIC API
+export type SentMessageInfo = any;
+
+// PUBLIC API
+export type Email = {
+  {=# isDefaultFromFieldDefined =}
+  from?: EmailFromField;
+  {=/ isDefaultFromFieldDefined =}
+  {=^ isDefaultFromFieldDefined =}
+  from: EmailFromField;
+  {=/ isDefaultFromFieldDefined =}
+  to: string;
+  subject: string;
+  text: string;
+  html: string;
+};
+
+// PUBLIC API
+export type EmailFromField = {
+  name?: string;
+  email: string;
+}