@baseplate-dev/plugin-auth 0.6.16 → 0.6.18

package/dist/local-auth/core/generators/auth-email-password/templates/module/services/invite.service.ts

@@ -0,0 +1,209 @@
+// @ts-nocheck
+
+import type { User } from '%prismaGeneratedImports';
+import type {
+  RequestServiceContext,
+  RequestServiceContextWith,
+} from '%requestServiceContextImports';
+import type { UserSessionPayload } from '%userSessionTypesImports';
+
+import {
+  AUTH_TOKEN_MAX_LENGTH,
+  INVITE_TOKEN_EXPIRY_SEC,
+  PASSWORD_MAX_LENGTH,
+  PASSWORD_MIN_LENGTH,
+} from '$constantsPassword';
+import {
+  createAuthVerification,
+  validateAuthVerification,
+} from '%authModuleImports';
+import { getConfig } from '%configServiceImports';
+import {
+  BadRequestError,
+  handleZodRequestValidationError,
+  NotFoundError,
+} from '%errorHandlerServiceImports';
+import { createPasswordHash } from '%passwordHasherServiceImports';
+import { prisma } from '%prismaImports';
+import z from 'zod';
+
+const PROVIDER_ID = 'email-password';
+const INVITE_TYPE = 'invite';
+
+/**
+ * Sends an invite email so a user can set their password and sign in.
+ * Admin-triggered, so unlike password reset requests, it does not need
+ * anti-enumeration rate limiting.
+ */
+export async function inviteUser({
+  userId,
+  context,
+}: {
+  userId: string;
+  context: RequestServiceContextWith<'email'>;
+}): Promise<{ user: User }> {
+  const { services } = context;
+
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+
+  if (!user) {
+    throw new NotFoundError('User not found', 'user-not-found');
+  }
+
+  if (!user.email) {
+    throw new BadRequestError('User has no email', 'user-has-no-email');
+  }
+
+  const existingAccount = await prisma.userAccount.findUnique({
+    where: {
+      accountId_providerId: {
+        accountId: user.email,
+        providerId: PROVIDER_ID,
+      },
+    },
+  });
+
+  if (existingAccount) {
+    throw new BadRequestError(
+      'User already has a password set',
+      'user-already-has-account',
+    );
+  }
+
+  const { token } = await createAuthVerification({
+    type: INVITE_TYPE,
+    userId: user.id,
+    expiresInSec: INVITE_TOKEN_EXPIRY_SEC,
+  });
+
+  const acceptLink = `${getConfig().AUTH_FRONTEND_URL}/auth/accept-invite?token=${encodeURIComponent(token)}`;
+
+  await services.email.send(TPL_INVITE_EMAIL, {
+    to: user.email,
+    data: { acceptLink },
+  });
+
+  return { user };
+}
+
+const validateTokenSchema = z.object({
+  token: z.string().min(1).max(AUTH_TOKEN_MAX_LENGTH),
+});
+
+/**
+ * Validates an invite token without consuming it.
+ * Used by the frontend to verify the token is valid and to show the
+ * invited email before displaying the set-password form.
+ *
+ * @throws BadRequestError with code 'invalid-token' if the token is invalid or expired
+ */
+export async function validateInviteToken({
+  token: rawToken,
+}: {
+  token: string;
+}): Promise<{ email: string }> {
+  const { token } = await validateTokenSchema
+    .parseAsync({ token: rawToken })
+    .catch(handleZodRequestValidationError);
+
+  const record = await validateAuthVerification({
+    type: INVITE_TYPE,
+    token,
+  });
+
+  if (!record?.userId) {
+    throw new BadRequestError('Invalid or expired token', 'invalid-token');
+  }
+
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: record.userId },
+    select: { email: true },
+  });
+
+  if (!user.email) {
+    throw new BadRequestError('User has no email', 'user-has-no-email');
+  }
+
+  return { email: user.email };
+}
+
+const acceptInviteSchema = z.object({
+  token: z.string().min(1).max(AUTH_TOKEN_MAX_LENGTH),
+  newPassword: z.string().min(PASSWORD_MIN_LENGTH).max(PASSWORD_MAX_LENGTH),
+});
+
+/**
+ * Completes the invite flow by setting the invited user's password and
+ * signing them in. Token is single-use (deleted after acceptance, along
+ * with any other pending invite tokens for the user).
+ */
+export async function acceptInvite({
+  token: rawToken,
+  newPassword: rawNewPassword,
+  context,
+}: {
+  token: string;
+  newPassword: string;
+  context: RequestServiceContext;
+}): Promise<{ session: UserSessionPayload }> {
+  const { token, newPassword } = await acceptInviteSchema
+    .parseAsync({
+      token: rawToken,
+      newPassword: rawNewPassword,
+    })
+    .catch(handleZodRequestValidationError);
+
+  const record = await validateAuthVerification({
+    type: INVITE_TYPE,
+    token,
+  });
+
+  if (!record?.userId) {
+    throw new BadRequestError('Invalid or expired token', 'invalid-token');
+  }
+
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: record.userId },
+    select: { id: true, email: true },
+  });
+
+  if (!user.email) {
+    throw new BadRequestError('User has no email', 'user-has-no-email');
+  }
+
+  const passwordHash = await createPasswordHash(newPassword);
+
+  await prisma.$transaction([
+    prisma.authVerification.deleteMany({
+      where: { type: INVITE_TYPE, userId: user.id },
+    }),
+    prisma.userAccount.upsert({
+      where: {
+        accountId_providerId: {
+          accountId: user.email,
+          providerId: PROVIDER_ID,
+        },
+      },
+      create: {
+        userId: user.id,
+        accountId: user.email,
+        providerId: PROVIDER_ID,
+        password: passwordHash,
+      },
+      update: {
+        password: passwordHash,
+      },
+    }),
+    prisma.user.update({
+      where: { id: user.id },
+      data: { emailVerified: true },
+    }),
+  ]);
+
+  const session = await context.services.userSession.createSession(
+    user.id,
+    context,
+  );
+
+  return { session };
+}

package/dist/local-auth/core/generators/auth-email-password/templates/module/services/password-reset.service.js

@@ -1,5 +1,5 @@
 // @ts-nocheck
-import { PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, PASSWORD_RESET_TOKEN_EXPIRY_SEC, } from '$constantsPassword';
+import { AUTH_TOKEN_MAX_LENGTH, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, PASSWORD_RESET_TOKEN_EXPIRY_SEC, } from '$constantsPassword';
 import { resetLoginRateLimits } from '$servicesUserPassword';
 import { createAuthVerification, validateAuthVerification, } from '%authModuleImports';
 import { getConfig } from '%configServiceImports';
@@ -70,7 +70,7 @@ export async function requestPasswordReset({ email: rawEmail, context, }) {
     return { success: true };
 }
 const validateTokenSchema = z.object({
-    token: z.string().min(1).max(PASSWORD_MAX_LENGTH),
+    token: z.string().min(1).max(AUTH_TOKEN_MAX_LENGTH),
 });
 /**
  * Validates a password reset token without consuming it.
@@ -92,7 +92,7 @@ export async function validatePasswordResetToken({ token: rawToken, }) {
     return { success: true };
 }
 const completePasswordResetSchema = z.object({
-    token: z.string().min(1).max(PASSWORD_MAX_LENGTH),
+    token: z.string().min(1).max(AUTH_TOKEN_MAX_LENGTH),
     newPassword: z.string().min(PASSWORD_MIN_LENGTH).max(PASSWORD_MAX_LENGTH),
 });
 /**

package/dist/local-auth/core/generators/auth-email-password/templates/module/services/password-reset.service.ts

@@ -3,6 +3,7 @@
 import type { RequestServiceContextWith } from '%requestServiceContextImports';
 
 import {
+  AUTH_TOKEN_MAX_LENGTH,
   PASSWORD_MAX_LENGTH,
   PASSWORD_MIN_LENGTH,
   PASSWORD_RESET_TOKEN_EXPIRY_SEC,
@@ -122,7 +123,7 @@ export async function requestPasswordReset({
 }
 
 const validateTokenSchema = z.object({
-  token: z.string().min(1).max(PASSWORD_MAX_LENGTH),
+  token: z.string().min(1).max(AUTH_TOKEN_MAX_LENGTH),
 });
 
 /**
@@ -153,7 +154,7 @@ export async function validatePasswordResetToken({
 }
 
 const completePasswordResetSchema = z.object({
-  token: z.string().min(1).max(PASSWORD_MAX_LENGTH),
+  token: z.string().min(1).max(AUTH_TOKEN_MAX_LENGTH),
   newPassword: z.string().min(PASSWORD_MIN_LENGTH).max(PASSWORD_MAX_LENGTH),
 });
 

package/dist/local-auth/core/generators/auth-email-templates/auth-email-templates.generator.d.ts

@@ -5,7 +5,9 @@
  * account verification) with the transactional email library and generates
  * the corresponding .tsx template files.
  */
-export declare const authEmailTemplatesGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<Record<string, never>, {
+export declare const authEmailTemplatesGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    emailOtp?: boolean | undefined;
+}, {
     paths: import("@baseplate-dev/sync").GeneratorTask<{
         localAuthAuthEmailTemplatesPaths: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-paths.js").LocalAuthAuthEmailTemplatesPaths>;
     }, {

package/dist/local-auth/core/generators/auth-email-templates/auth-email-templates.generator.js

@@ -2,7 +2,9 @@ import { emailTemplatesProvider } from '@baseplate-dev/plugin-email';
 import { createGenerator, createGeneratorTask } from '@baseplate-dev/sync';
 import { z } from 'zod';
 import { LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_GENERATED as GENERATED_TEMPLATES } from './generated/index.js';
-const descriptorSchema = z.object({});
+const descriptorSchema = z.object({
+    emailOtp: z.boolean().default(false),
+});
 /**
  * Generator for auth email templates.
  *
@@ -14,7 +16,7 @@ export const authEmailTemplatesGenerator = createGenerator({
     name: 'local-auth/auth-email-templates',
     generatorFileUrl: import.meta.url,
     descriptorSchema,
-    buildTasks: () => ({
+    buildTasks: ({ emailOtp }) => ({
         paths: GENERATED_TEMPLATES.paths.task,
         renderers: GENERATED_TEMPLATES.renderers.task,
         main: createGeneratorTask({
@@ -36,9 +38,22 @@ export const authEmailTemplatesGenerator = createGenerator({
                     exportName: 'PasswordResetEmail',
                     exportPath: paths.passwordResetEmail,
                 });
+                emailTemplates.registerExport({
+                    exportName: 'InviteEmail',
+                    exportPath: paths.inviteEmail,
+                });
+                if (emailOtp) {
+                    emailTemplates.registerExport({
+                        exportName: 'EmailOtpEmail',
+                        exportPath: paths.emailOtpEmail,
+                    });
+                }
                 return {
                     build: async (builder) => {
-                        await builder.apply(renderers.accountVerificationEmail.render({}), renderers.passwordChangedEmail.render({}), renderers.passwordResetEmail.render({}));
+                        await builder.apply(renderers.accountVerificationEmail.render({}), renderers.passwordChangedEmail.render({}), renderers.passwordResetEmail.render({}), renderers.inviteEmail.render({}));
+                        if (emailOtp) {
+                            await builder.apply(renderers.emailOtpEmail.render({}));
+                        }
                     },
                 };
             },

package/dist/local-auth/core/generators/auth-email-templates/generated/index.d.ts

@@ -55,6 +55,46 @@ export declare const LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_GENERATED: {
                 theme: {};
             }>>;
         }, Record<never, Record<never, never>>>;
+        emailOtpEmail: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            transactionalLibImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                Button: {};
+                defineEmail: {};
+                DefineEmailOptions: {
+                    isTypeOnly: true;
+                };
+                Divider: {};
+                EmailComponent: {
+                    isTypeOnly: true;
+                };
+                EmailLayout: {};
+                Heading: {};
+                Link: {};
+                renderEmail: {};
+                Section: {};
+                Text: {};
+                theme: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+        inviteEmail: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            transactionalLibImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                Button: {};
+                defineEmail: {};
+                DefineEmailOptions: {
+                    isTypeOnly: true;
+                };
+                Divider: {};
+                EmailComponent: {
+                    isTypeOnly: true;
+                };
+                EmailLayout: {};
+                Heading: {};
+                Link: {};
+                renderEmail: {};
+                Section: {};
+                Text: {};
+                theme: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
         passwordChangedEmail: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
             transactionalLibImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 Button: {};

package/dist/local-auth/core/generators/auth-email-templates/generated/template-paths.d.ts

@@ -1,5 +1,7 @@
 export interface LocalAuthAuthEmailTemplatesPaths {
     accountVerificationEmail: string;
+    emailOtpEmail: string;
+    inviteEmail: string;
     passwordChangedEmail: string;
     passwordResetEmail: string;
 }

package/dist/local-auth/core/generators/auth-email-templates/generated/template-paths.js

@@ -12,6 +12,8 @@ const localAuthAuthEmailTemplatesPathsTask = createGeneratorTask({
             providers: {
                 localAuthAuthEmailTemplatesPaths: {
                     accountVerificationEmail: `${srcRoot}/emails/auth/account-verification.email.tsx`,
+                    emailOtpEmail: `${srcRoot}/emails/auth/email-otp.email.tsx`,
+                    inviteEmail: `${srcRoot}/emails/auth/invite.email.tsx`,
                     passwordChangedEmail: `${srcRoot}/emails/auth/password-changed.email.tsx`,
                     passwordResetEmail: `${srcRoot}/emails/auth/password-reset.email.tsx`,
                 },

package/dist/local-auth/core/generators/auth-email-templates/generated/template-renderers.d.ts

@@ -5,6 +5,12 @@ export interface LocalAuthAuthEmailTemplatesRenderers {
     accountVerificationEmail: {
         render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES.accountVerificationEmail>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
     };
+    emailOtpEmail: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES.emailOtpEmail>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    inviteEmail: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES.inviteEmail>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
     passwordChangedEmail: {
         render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES.passwordChangedEmail>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
     };

package/dist/local-auth/core/generators/auth-email-templates/generated/template-renderers.js

@@ -27,6 +27,26 @@ const localAuthAuthEmailTemplatesRenderersTask = createGeneratorTask({
                             ...options,
                         }),
                     },
+                    emailOtpEmail: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES.emailOtpEmail,
+                            destination: paths.emailOtpEmail,
+                            importMapProviders: {
+                                transactionalLibImports,
+                            },
+                            ...options,
+                        }),
+                    },
+                    inviteEmail: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES.inviteEmail,
+                            destination: paths.inviteEmail,
+                            importMapProviders: {
+                                transactionalLibImports,
+                            },
+                            ...options,
+                        }),
+                    },
                     passwordChangedEmail: {
                         render: (options) => typescriptFile.renderTemplateFile({
                             template: LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES.passwordChangedEmail,

package/dist/local-auth/core/generators/auth-email-templates/generated/typed-templates.d.ts

@@ -19,6 +19,46 @@ export declare const LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES: {
             theme: {};
         }>>;
     }, Record<never, Record<never, never>>>;
+    emailOtpEmail: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        transactionalLibImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            Button: {};
+            defineEmail: {};
+            DefineEmailOptions: {
+                isTypeOnly: true;
+            };
+            Divider: {};
+            EmailComponent: {
+                isTypeOnly: true;
+            };
+            EmailLayout: {};
+            Heading: {};
+            Link: {};
+            renderEmail: {};
+            Section: {};
+            Text: {};
+            theme: {};
+        }>>;
+    }, Record<never, Record<never, never>>>;
+    inviteEmail: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        transactionalLibImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            Button: {};
+            defineEmail: {};
+            DefineEmailOptions: {
+                isTypeOnly: true;
+            };
+            Divider: {};
+            EmailComponent: {
+                isTypeOnly: true;
+            };
+            EmailLayout: {};
+            Heading: {};
+            Link: {};
+            renderEmail: {};
+            Section: {};
+            Text: {};
+            theme: {};
+        }>>;
+    }, Record<never, Record<never, never>>>;
     passwordChangedEmail: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
         transactionalLibImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             Button: {};

package/dist/local-auth/core/generators/auth-email-templates/generated/typed-templates.js

@@ -12,6 +12,28 @@ const accountVerificationEmail = createTsTemplateFile({
     },
     variables: {},
 });
+const emailOtpEmail = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {
+        transactionalLibImports: transactionalLibImportsProvider,
+    },
+    name: 'email-otp-email',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/src/emails/auth/email-otp.email.tsx'),
+    },
+    variables: {},
+});
+const inviteEmail = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {
+        transactionalLibImports: transactionalLibImportsProvider,
+    },
+    name: 'invite-email',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/src/emails/auth/invite.email.tsx'),
+    },
+    variables: {},
+});
 const passwordChangedEmail = createTsTemplateFile({
     fileOptions: { kind: 'singleton' },
     importMapProviders: {
@@ -36,6 +58,8 @@ const passwordResetEmail = createTsTemplateFile({
 });
 export const LOCAL_AUTH_AUTH_EMAIL_TEMPLATES_TEMPLATES = {
     accountVerificationEmail,
+    emailOtpEmail,
+    inviteEmail,
     passwordChangedEmail,
     passwordResetEmail,
 };

package/dist/local-auth/core/generators/auth-email-templates/templates/src/emails/auth/email-otp.email.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=email-otp.email.d.ts.map

package/dist/local-auth/core/generators/auth-email-templates/templates/src/emails/auth/email-otp.email.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+import { defineEmail, Divider, EmailLayout, Heading, Section, Text, theme, } from '%transactionalLibImports';
+import * as React from 'react';
+export default defineEmail(EmailOtpEmail, {
+    // Code first: inbox lists and notification previews truncate early, so many
+    // users never need to open the message. It also makes each resend visually
+    // distinct in clients that collapse threads by subject.
+    subject: ({ code }) => `${code} is your ${theme.branding.name} sign-in code`,
+    previewProps: {
+        code: '123456',
+        expiryMinutes: 10,
+    },
+});
+function EmailOtpEmail({ code, expiryMinutes, }) {
+    return (_jsxs(EmailLayout, { previewText: `Your ${theme.branding.name} sign-in code`, children: [_jsx(Heading, { as: "h2", children: "Your sign-in code" }), _jsxs(Text, { children: ["Enter this code to finish signing in to ", theme.branding.name, "."] }), _jsx(Section, { align: "center", children: _jsx(Text, { children: _jsx("strong", { style: { fontSize: '28px', letterSpacing: '6px' }, children: code }) }) }), _jsxs(Text, { children: ["This code expires in ", expiryMinutes, " minutes."] }), _jsx(Divider, { spacing: "lg" }), _jsx(Text, { variant: "muted", children: "If you didn't request this code, you can safely ignore this email. Someone may have typed your email address by mistake." })] }));
+}
+//# sourceMappingURL=email-otp.email.js.map

package/dist/local-auth/core/generators/auth-email-templates/templates/src/emails/auth/email-otp.email.tsx

@@ -0,0 +1,57 @@
+// @ts-nocheck
+
+import {
+  defineEmail,
+  Divider,
+  EmailLayout,
+  Heading,
+  Section,
+  Text,
+  theme,
+} from '%transactionalLibImports';
+import * as React from 'react';
+
+interface EmailOtpProps {
+  code: string;
+  expiryMinutes: number;
+}
+
+export default defineEmail(EmailOtpEmail, {
+  // Code first: inbox lists and notification previews truncate early, so many
+  // users never need to open the message. It also makes each resend visually
+  // distinct in clients that collapse threads by subject.
+  subject: ({ code }) => `${code} is your ${theme.branding.name} sign-in code`,
+  previewProps: {
+    code: '123456',
+    expiryMinutes: 10,
+  },
+});
+
+function EmailOtpEmail({
+  code,
+  expiryMinutes,
+}: EmailOtpProps): React.ReactElement {
+  return (
+    <EmailLayout previewText={`Your ${theme.branding.name} sign-in code`}>
+      <Heading as="h2">Your sign-in code</Heading>
+      <Text>
+        Enter this code to finish signing in to {theme.branding.name}.
+      </Text>
+
+      <Section align="center">
+        <Text>
+          <strong style={{ fontSize: '28px', letterSpacing: '6px' }}>
+            {code}
+          </strong>
+        </Text>
+      </Section>
+
+      <Text>This code expires in {expiryMinutes} minutes.</Text>
+      <Divider spacing="lg" />
+      <Text variant="muted">
+        If you didn&apos;t request this code, you can safely ignore this email.
+        Someone may have typed your email address by mistake.
+      </Text>
+    </EmailLayout>
+  );
+}

package/dist/local-auth/core/generators/auth-email-templates/templates/src/emails/auth/invite.email.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=invite.email.d.ts.map

package/dist/local-auth/core/generators/auth-email-templates/templates/src/emails/auth/invite.email.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+import { Button, defineEmail, Divider, EmailLayout, Heading, Section, Text, theme, } from '%transactionalLibImports';
+import * as React from 'react';
+export default defineEmail(InviteEmail, {
+    subject: `You've been invited to ${theme.branding.name}`,
+    previewProps: {
+        acceptLink: 'https://example.com',
+    },
+});
+function InviteEmail({ acceptLink }) {
+    return (_jsxs(EmailLayout, { previewText: `You've been invited to ${theme.branding.name}`, children: [_jsx(Heading, { as: "h2", children: "You've been invited" }), _jsxs(Text, { children: ["You've been invited to join ", theme.branding.name, ". Click the button below to set your password and get started."] }), _jsx(Section, { align: "center", children: _jsx(Button, { href: acceptLink, children: "Accept Invite" }) }), _jsx(Divider, { spacing: "lg" }), _jsx(Text, { variant: "muted", children: "If you weren't expecting this invite, you can safely ignore this email." })] }));
+}
+//# sourceMappingURL=invite.email.js.map

package/dist/local-auth/core/generators/auth-email-templates/templates/src/emails/auth/invite.email.tsx

@@ -0,0 +1,47 @@
+// @ts-nocheck
+
+import {
+  Button,
+  defineEmail,
+  Divider,
+  EmailLayout,
+  Heading,
+  Section,
+  Text,
+  theme,
+} from '%transactionalLibImports';
+import * as React from 'react';
+
+interface InviteProps {
+  acceptLink: string;
+}
+
+export default defineEmail(InviteEmail, {
+  subject: `You've been invited to ${theme.branding.name}`,
+  previewProps: {
+    acceptLink: 'https://example.com',
+  },
+});
+
+function InviteEmail({ acceptLink }: InviteProps): React.ReactElement {
+  return (
+    <EmailLayout previewText={`You've been invited to ${theme.branding.name}`}>
+      <Heading as="h2">You've been invited</Heading>
+
+      <Text>
+        You've been invited to join {theme.branding.name}. Click the button
+        below to set your password and get started.
+      </Text>
+
+      <Section align="center">
+        <Button href={acceptLink}>Accept Invite</Button>
+      </Section>
+
+      <Divider spacing="lg" />
+
+      <Text variant="muted">
+        If you weren't expecting this invite, you can safely ignore this email.
+      </Text>
+    </EmailLayout>
+  );
+}