@baseplate-dev/plugin-auth 0.6.17 → 0.6.19

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

@@ -0,0 +1,142 @@
+// @ts-nocheck
+import { AUTH_TOKEN_MAX_LENGTH, INVITE_TOKEN_EXPIRY_SEC, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, } from '$constantsPassword';
+import { getWebUrl } from '%appUrlsImports';
+import { createAuthVerification, validateAuthVerification, } from '%authModuleImports';
+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, }) {
+    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 = getWebUrl(TPL_AUTH_WEB_APP, `/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, }) {
+    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, }) {
+    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');
+    }
+    // The invite token outlives the check in `inviteUser`, so the user may have
+    // registered in the meantime.
+    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 passwordHash = await createPasswordHash(newPassword);
+    await prisma.$transaction([
+        prisma.authVerification.deleteMany({
+            where: { type: INVITE_TYPE, userId: user.id },
+        }),
+        prisma.userAccount.create({
+            data: {
+                userId: user.id,
+                accountId: user.email,
+                providerId: PROVIDER_ID,
+                password: passwordHash,
+            },
+        }),
+        prisma.user.update({
+            where: { id: user.id },
+            data: { emailVerified: true },
+        }),
+    ]);
+    const session = await context.services.userSession.createSession(user.id, context);
+    return { session };
+}
+//# sourceMappingURL=invite.service.js.map

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

@@ -0,0 +1,221 @@
+// @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 { getWebUrl } from '%appUrlsImports';
+import {
+  createAuthVerification,
+  validateAuthVerification,
+} from '%authModuleImports';
+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 = getWebUrl(
+    TPL_AUTH_WEB_APP,
+    `/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');
+  }
+
+  // The invite token outlives the check in `inviteUser`, so the user may have
+  // registered in the meantime.
+  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 passwordHash = await createPasswordHash(newPassword);
+
+  await prisma.$transaction([
+    prisma.authVerification.deleteMany({
+      where: { type: INVITE_TYPE, userId: user.id },
+    }),
+    prisma.userAccount.create({
+      data: {
+        userId: user.id,
+        accountId: user.email,
+        providerId: PROVIDER_ID,
+        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,8 +1,8 @@
 // @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 { getWebAppForUrl, getWebUrl } from '%appUrlsImports';
 import { createAuthVerification, validateAuthVerification, } from '%authModuleImports';
-import { getConfig } from '%configServiceImports';
 import { BadRequestError, handleZodRequestValidationError, } from '%errorHandlerServiceImports';
 import { createPasswordHash } from '%passwordHasherServiceImports';
 import { prisma } from '%prismaImports';
@@ -58,8 +58,7 @@ export async function requestPasswordReset({ email: rawEmail, context, }) {
             userId: user.id,
             expiresInSec: PASSWORD_RESET_TOKEN_EXPIRY_SEC,
         });
-        // Construct reset URL using configured domain
-        const resetLink = `${getConfig().AUTH_FRONTEND_URL}/auth/reset-password?token=${encodeURIComponent(token)}`;
+        const resetLink = getWebUrl(getWebAppForUrl(context.reqInfo.headers.origin) ?? TPL_AUTH_WEB_APP, `/auth/reset-password?token=${encodeURIComponent(token)}`);
         // Send email asynchronously (queue-based)
         await services.email.send(TPL_PASSWORD_RESET_EMAIL, {
             to: user.email,
@@ -70,7 +69,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 +91,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,16 +3,17 @@
 import type { RequestServiceContextWith } from '%requestServiceContextImports';
 
 import {
+  AUTH_TOKEN_MAX_LENGTH,
   PASSWORD_MAX_LENGTH,
   PASSWORD_MIN_LENGTH,
   PASSWORD_RESET_TOKEN_EXPIRY_SEC,
 } from '$constantsPassword';
 import { resetLoginRateLimits } from '$servicesUserPassword';
+import { getWebAppForUrl, getWebUrl } from '%appUrlsImports';
 import {
   createAuthVerification,
   validateAuthVerification,
 } from '%authModuleImports';
-import { getConfig } from '%configServiceImports';
 import {
   BadRequestError,
   handleZodRequestValidationError,
@@ -107,8 +108,10 @@ export async function requestPasswordReset({
       expiresInSec: PASSWORD_RESET_TOKEN_EXPIRY_SEC,
     });
 
-    // Construct reset URL using configured domain
-    const resetLink = `${getConfig().AUTH_FRONTEND_URL}/auth/reset-password?token=${encodeURIComponent(token)}`;
+    const resetLink = getWebUrl(
+      getWebAppForUrl(context.reqInfo.headers.origin) ?? TPL_AUTH_WEB_APP,
+      `/auth/reset-password?token=${encodeURIComponent(token)}`,
+    );
 
     // Send email asynchronously (queue-based)
     await services.email.send(TPL_PASSWORD_RESET_EMAIL, {
@@ -122,7 +125,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 +156,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: {};