@baseplate-dev/plugin-auth 0.6.17 → 0.6.18

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

@@ -1,4 +1,4 @@
-import { tsCodeFragment, TsCodeUtils } from '@baseplate-dev/core-generators';
+import { tsCodeFragment, TsCodeUtils, tsImportBuilder, } from '@baseplate-dev/core-generators';
 import { appModuleProvider, configServiceProvider, createPothosPrismaObjectTypeOutputName, pothosTypeOutputProvider, } from '@baseplate-dev/fastify-generators';
 import { transactionalLibConfigProvider } from '@baseplate-dev/plugin-email';
 import { createGenerator, createGeneratorTask, createProviderTask, } from '@baseplate-dev/sync';
@@ -10,6 +10,8 @@ const descriptorSchema = z.object({
     adminRoles: z.array(z.string()),
     devWebDomainPort: z.number(),
     requireNameOnRegistration: z.boolean(),
+    emailOtp: z.boolean().default(false),
+    disableRegistration: z.boolean().default(false),
 });
 /**
  * Sets up email / password authentication
@@ -18,7 +20,7 @@ export const authEmailPasswordGenerator = createGenerator({
     name: 'local-auth/core/auth-email-password',
     generatorFileUrl: import.meta.url,
     descriptorSchema,
-    buildTasks: ({ adminRoles, devWebDomainPort, requireNameOnRegistration, }) => ({
+    buildTasks: ({ adminRoles, devWebDomainPort, requireNameOnRegistration, emailOtp, disableRegistration, }) => ({
         paths: GENERATED_TEMPLATES.paths.task,
         imports: GENERATED_TEMPLATES.imports.task,
         renderers: GENERATED_TEMPLATES.renderers.task,
@@ -35,26 +37,59 @@ export const authEmailPasswordGenerator = createGenerator({
                 appModule: appModuleProvider,
             },
             run({ paths, appModule }) {
-                appModule.moduleImports.push(paths.schemaUserPasswordMutations, paths.schemaPasswordResetMutations, paths.schemaEmailVerificationMutations);
+                appModule.moduleImports.push(paths.schemaUserPasswordMutations, paths.schemaPasswordResetMutations, paths.schemaInviteMutations, paths.schemaEmailVerificationMutations);
+                if (emailOtp) {
+                    appModule.moduleImports.push(paths.schemaEmailOtpMutations);
+                }
             },
         }),
         main: createGeneratorTask({
             dependencies: {
+                paths: GENERATED_TEMPLATES.paths.provider,
                 renderers: GENERATED_TEMPLATES.renderers.provider,
                 transactionalLibConfig: transactionalLibConfigProvider,
                 userObjectType: pothosTypeOutputProvider
                     .dependency()
                     .reference(createPothosPrismaObjectTypeOutputName(LOCAL_AUTH_MODELS.user)),
             },
-            run({ renderers, transactionalLibConfig, userObjectType }) {
+            run({ paths, renderers, transactionalLibConfig, userObjectType }) {
                 const transactionalLibPackageName = transactionalLibConfig.getTransactionalLibPackageName();
+                const adminRolesFragment = TsCodeUtils.mergeFragmentsAsArrayPresorted(adminRoles.map((r) => quot(r)).toSorted());
+                const userObjectTypeFragment = userObjectType.getTypeReference().fragment;
+                // Kept as its own fragment (rather than a separate mutations file)
+                // since the backend serves every web app, and only one field needs
+                // to disappear when every web app has registration disabled.
+                const registerMutationFragment = disableRegistration
+                    ? ''
+                    : tsCodeFragment(`builder.mutationField('registerWithEmailPassword', (t) =>
+  t.fieldWithInputPayload({
+    authorize: ['public'],
+    payload: {
+      session: t.payload.field({ type: userSessionPayload }),
+    },
+    input: {
+      email: t.input.field({ required: true, type: 'String' }),
+      name: t.input.field({ required: false, type: 'String' }),
+      password: t.input.field({ required: true, type: 'String' }),
+    },
+    resolve: async (root, { input }, context) =>
+      registerUserWithEmailAndPassword({
+        input: {
+          ...input,
+          name: input.name ?? undefined,
+        },
+        context,
+      }),
+  }),
+);`, tsImportBuilder(['registerUserWithEmailAndPassword']).from(paths.servicesUserPassword));
                 return {
                     build: async (builder) => {
                         await builder.apply(renderers.moduleGroup.render({
                             variables: {
                                 schemaUserPasswordMutations: {
-                                    TPL_ADMIN_ROLES: TsCodeUtils.mergeFragmentsAsArrayPresorted(adminRoles.map((r) => quot(r)).toSorted()),
-                                    TPL_USER_OBJECT_TYPE: userObjectType.getTypeReference().fragment,
+                                    TPL_ADMIN_ROLES: adminRolesFragment,
+                                    TPL_REGISTER_MUTATION: registerMutationFragment,
+                                    TPL_USER_OBJECT_TYPE: userObjectTypeFragment,
                                 },
                                 servicesPasswordReset: {
                                     TPL_PASSWORD_RESET_EMAIL: TsCodeUtils.importFragment('PasswordResetEmail', transactionalLibPackageName),
@@ -67,12 +102,37 @@ export const authEmailPasswordGenerator = createGenerator({
                                 },
                             },
                         }));
+                        await builder.apply(renderers.servicesInvite.render({
+                            variables: {
+                                TPL_INVITE_EMAIL: TsCodeUtils.importFragment('InviteEmail', transactionalLibPackageName),
+                            },
+                        }));
+                        await builder.apply(renderers.schemaInviteMutations.render({
+                            variables: {
+                                TPL_ADMIN_ROLES: adminRolesFragment,
+                                TPL_USER_OBJECT_TYPE: userObjectTypeFragment,
+                            },
+                        }));
                         await builder.apply(renderers.servicesEmailVerification.render({
                             variables: {
                                 TPL_ACCOUNT_VERIFICATION_EMAIL: TsCodeUtils.importFragment('AccountVerificationEmail', transactionalLibPackageName),
                             },
                         }));
                         await builder.apply(renderers.schemaEmailVerificationMutations.render({}));
+                        if (emailOtp) {
+                            await builder.apply(renderers.constantsOtp.render({}));
+                            await builder.apply(renderers.servicesEmailOtp.render({
+                                variables: {
+                                    TPL_EMAIL_OTP_EMAIL: TsCodeUtils.importFragment('EmailOtpEmail', transactionalLibPackageName),
+                                    // The user lookup lives inside the fragment so it is not
+                                    // left unused when names are not required.
+                                    TPL_NAME_REQUIRED_CHECK: requireNameOnRegistration
+                                        ? tsCodeFragment("const existingUser = await prisma.user.findUnique({\n    where: { email },\n    select: { id: true },\n  });\n\n  if (!existingUser && !name) {\n    throw new BadRequestError('Name is required', 'name-required');\n  }")
+                                        : '',
+                                },
+                            }));
+                            await builder.apply(renderers.schemaEmailOtpMutations.render({}));
+                        }
                     },
                 };
             },

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

@@ -34,10 +34,13 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
                 cleanupAuthVerificationQueue: {};
                 cleanupAuthVerificationWorker: {};
                 cleanupExpiredAuthVerifications: {};
+                consumeCodeVerification: {};
                 CookieUserSessionService: {};
                 createAuthVerification: {};
+                createCodeVerification: {};
                 userSessionPayload: {};
                 validateAuthVerification: {};
+                validateCodeVerification: {};
             }>>;
             configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 getConfig: {};
@@ -106,6 +109,7 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
         }, undefined>;
     };
     templates: {
+        constantsOtp: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
         moduleGroup: {
             constantsPassword: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
             schemaPasswordResetMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
@@ -117,16 +121,20 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
             }>;
             schemaUserPasswordMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{
                 TPL_ADMIN_ROLES: {};
+                TPL_REGISTER_MUTATION: {};
                 TPL_USER_OBJECT_TYPE: {};
             }, {
                 authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                     cleanupAuthVerificationQueue: {};
                     cleanupAuthVerificationWorker: {};
                     cleanupExpiredAuthVerifications: {};
+                    consumeCodeVerification: {};
                     CookieUserSessionService: {};
                     createAuthVerification: {};
+                    createCodeVerification: {};
                     userSessionPayload: {};
                     validateAuthVerification: {};
+                    validateCodeVerification: {};
                 }>>;
                 pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                     builder: {};
@@ -142,10 +150,13 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
                     cleanupAuthVerificationQueue: {};
                     cleanupAuthVerificationWorker: {};
                     cleanupExpiredAuthVerifications: {};
+                    consumeCodeVerification: {};
                     CookieUserSessionService: {};
                     createAuthVerification: {};
+                    createCodeVerification: {};
                     userSessionPayload: {};
                     validateAuthVerification: {};
+                    validateCodeVerification: {};
                 }>>;
                 configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                     getConfig: {};
@@ -259,6 +270,25 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
                 servicesEmailVerification: {};
             }>;
         };
+        schemaEmailOtpMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                cleanupAuthVerificationQueue: {};
+                cleanupAuthVerificationWorker: {};
+                cleanupExpiredAuthVerifications: {};
+                consumeCodeVerification: {};
+                CookieUserSessionService: {};
+                createAuthVerification: {};
+                createCodeVerification: {};
+                userSessionPayload: {};
+                validateAuthVerification: {};
+                validateCodeVerification: {};
+            }>>;
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+        }, {
+            servicesEmailOtp: {};
+        }>;
         schemaEmailVerificationMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
             pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 builder: {};
@@ -266,6 +296,97 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
         }, {
             servicesEmailVerification: {};
         }>;
+        schemaInviteMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{
+            TPL_ADMIN_ROLES: {};
+            TPL_USER_OBJECT_TYPE: {};
+        }, {
+            authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                cleanupAuthVerificationQueue: {};
+                cleanupAuthVerificationWorker: {};
+                cleanupExpiredAuthVerifications: {};
+                consumeCodeVerification: {};
+                CookieUserSessionService: {};
+                createAuthVerification: {};
+                createCodeVerification: {};
+                userSessionPayload: {};
+                validateAuthVerification: {};
+                validateCodeVerification: {};
+            }>>;
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+        }, {
+            servicesInvite: {};
+        }>;
+        servicesEmailOtp: import("@baseplate-dev/core-generators").TsTemplateFile<{
+            TPL_EMAIL_OTP_EMAIL: {};
+            TPL_NAME_REQUIRED_CHECK: {};
+        }, {
+            authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                cleanupAuthVerificationQueue: {};
+                cleanupAuthVerificationWorker: {};
+                cleanupExpiredAuthVerifications: {};
+                consumeCodeVerification: {};
+                CookieUserSessionService: {};
+                createAuthVerification: {};
+                createCodeVerification: {};
+                userSessionPayload: {};
+                validateAuthVerification: {};
+                validateCodeVerification: {};
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                getConfig: {};
+                isDevelopment: {};
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                throwIfPrismaNotFound: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                prisma: {};
+            }>>;
+            rateLimitImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createRateLimiter: {};
+                memoizeRateLimiter: {};
+                RateLimiter: {
+                    isTypeOnly: true;
+                };
+                RateLimiterConfig: {
+                    isTypeOnly: true;
+                };
+                RateLimitResult: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createContextFromRequest: {};
+                RequestServiceContext: {
+                    isTypeOnly: true;
+                };
+                RequestServiceContextWith: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionPayload: {
+                    isTypeOnly: true;
+                };
+                UserSessionService: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, {
+            constantsOtp: {};
+            constantsPassword: {};
+        }>;
         servicesEmailVerification: import("@baseplate-dev/core-generators").TsTemplateFile<{
             TPL_ACCOUNT_VERIFICATION_EMAIL: {};
         }, {
@@ -273,10 +394,13 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
                 cleanupAuthVerificationQueue: {};
                 cleanupAuthVerificationWorker: {};
                 cleanupExpiredAuthVerifications: {};
+                consumeCodeVerification: {};
                 CookieUserSessionService: {};
                 createAuthVerification: {};
+                createCodeVerification: {};
                 userSessionPayload: {};
                 validateAuthVerification: {};
+                validateCodeVerification: {};
             }>>;
             configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 getConfig: {};
@@ -322,6 +446,70 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
         }, {
             constantsPassword: {};
         }>;
+        servicesInvite: import("@baseplate-dev/core-generators").TsTemplateFile<{
+            TPL_INVITE_EMAIL: {};
+        }, {
+            authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                cleanupAuthVerificationQueue: {};
+                cleanupAuthVerificationWorker: {};
+                cleanupExpiredAuthVerifications: {};
+                consumeCodeVerification: {};
+                CookieUserSessionService: {};
+                createAuthVerification: {};
+                createCodeVerification: {};
+                userSessionPayload: {};
+                validateAuthVerification: {};
+                validateCodeVerification: {};
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                getConfig: {};
+                isDevelopment: {};
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                throwIfPrismaNotFound: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            passwordHasherServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createPasswordHash: {};
+                verifyPasswordHash: {};
+            }>>;
+            prismaGeneratedImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                PrismaClient: {};
+                Prisma: {};
+                '*': {};
+                $Enums: {};
+            }>>;
+            prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                prisma: {};
+            }>>;
+            requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createContextFromRequest: {};
+                RequestServiceContext: {
+                    isTypeOnly: true;
+                };
+                RequestServiceContextWith: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionPayload: {
+                    isTypeOnly: true;
+                };
+                UserSessionService: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, {
+            constantsPassword: {};
+        }>;
     };
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,9 +1,14 @@
 export interface LocalAuthCoreAuthEmailPasswordPaths {
+    constantsOtp: string;
     constantsPassword: string;
+    schemaEmailOtpMutations: string;
     schemaEmailVerificationMutations: string;
+    schemaInviteMutations: string;
     schemaPasswordResetMutations: string;
     schemaUserPasswordMutations: string;
+    servicesEmailOtp: string;
     servicesEmailVerification: string;
+    servicesInvite: string;
     servicesPasswordReset: string;
     servicesUserPassword: string;
 }

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

@@ -11,11 +11,16 @@ const localAuthCoreAuthEmailPasswordPathsTask = createGeneratorTask({
         return {
             providers: {
                 localAuthCoreAuthEmailPasswordPaths: {
+                    constantsOtp: `${moduleRoot}/constants/otp.constants.ts`,
                     constantsPassword: `${moduleRoot}/constants/password.constants.ts`,
+                    schemaEmailOtpMutations: `${moduleRoot}/schema/email-otp.mutations.ts`,
                     schemaEmailVerificationMutations: `${moduleRoot}/schema/email-verification.mutations.ts`,
+                    schemaInviteMutations: `${moduleRoot}/schema/invite.mutations.ts`,
                     schemaPasswordResetMutations: `${moduleRoot}/schema/password-reset.mutations.ts`,
                     schemaUserPasswordMutations: `${moduleRoot}/schema/user-password.mutations.ts`,
+                    servicesEmailOtp: `${moduleRoot}/services/email-otp.service.ts`,
                     servicesEmailVerification: `${moduleRoot}/services/email-verification.service.ts`,
+                    servicesInvite: `${moduleRoot}/services/invite.service.ts`,
                     servicesPasswordReset: `${moduleRoot}/services/password-reset.service.ts`,
                     servicesUserPassword: `${moduleRoot}/services/user-password.service.ts`,
                 },

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

@@ -2,15 +2,30 @@ import type { RenderTsTemplateFileActionInput, RenderTsTemplateGroupActionInput
 import type { BuilderAction } from '@baseplate-dev/sync';
 import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES } from './typed-templates.js';
 export interface LocalAuthCoreAuthEmailPasswordRenderers {
+    constantsOtp: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.constantsOtp>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
     moduleGroup: {
         render: (options: Omit<RenderTsTemplateGroupActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.moduleGroup>, 'importMapProviders' | 'group' | 'paths' | 'generatorPaths'>) => BuilderAction;
     };
+    schemaEmailOtpMutations: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaEmailOtpMutations>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
     schemaEmailVerificationMutations: {
         render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaEmailVerificationMutations>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
     };
+    schemaInviteMutations: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaInviteMutations>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    servicesEmailOtp: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesEmailOtp>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
     servicesEmailVerification: {
         render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesEmailVerification>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
     };
+    servicesInvite: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesInvite>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
 }
 export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_RENDERERS: {
     provider: import("@baseplate-dev/sync").ProviderType<LocalAuthCoreAuthEmailPasswordRenderers>;
@@ -21,10 +36,13 @@ export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_RENDERERS: {
             cleanupAuthVerificationQueue: {};
             cleanupAuthVerificationWorker: {};
             cleanupExpiredAuthVerifications: {};
+            consumeCodeVerification: {};
             CookieUserSessionService: {};
             createAuthVerification: {};
+            createCodeVerification: {};
             userSessionPayload: {};
             validateAuthVerification: {};
+            validateCodeVerification: {};
         }>>;
         configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             getConfig: {};

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

@@ -28,6 +28,13 @@ const localAuthCoreAuthEmailPasswordRenderersTask = createGeneratorTask({
         return {
             providers: {
                 localAuthCoreAuthEmailPasswordRenderers: {
+                    constantsOtp: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.constantsOtp,
+                            destination: paths.constantsOtp,
+                            ...options,
+                        }),
+                    },
                     moduleGroup: {
                         render: (options) => typescriptFile.renderTemplateGroup({
                             group: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.moduleGroup,
@@ -48,6 +55,18 @@ const localAuthCoreAuthEmailPasswordRenderersTask = createGeneratorTask({
                             ...options,
                         }),
                     },
+                    schemaEmailOtpMutations: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaEmailOtpMutations,
+                            destination: paths.schemaEmailOtpMutations,
+                            importMapProviders: {
+                                authModuleImports,
+                                pothosImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
                     schemaEmailVerificationMutations: {
                         render: (options) => typescriptFile.renderTemplateFile({
                             template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaEmailVerificationMutations,
@@ -59,6 +78,35 @@ const localAuthCoreAuthEmailPasswordRenderersTask = createGeneratorTask({
                             ...options,
                         }),
                     },
+                    schemaInviteMutations: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaInviteMutations,
+                            destination: paths.schemaInviteMutations,
+                            importMapProviders: {
+                                authModuleImports,
+                                pothosImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                    servicesEmailOtp: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesEmailOtp,
+                            destination: paths.servicesEmailOtp,
+                            importMapProviders: {
+                                authModuleImports,
+                                configServiceImports,
+                                errorHandlerServiceImports,
+                                prismaImports,
+                                rateLimitImports,
+                                requestServiceContextImports,
+                                userSessionTypesImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
                     servicesEmailVerification: {
                         render: (options) => typescriptFile.renderTemplateFile({
                             template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesEmailVerification,
@@ -75,6 +123,24 @@ const localAuthCoreAuthEmailPasswordRenderersTask = createGeneratorTask({
                             ...options,
                         }),
                     },
+                    servicesInvite: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesInvite,
+                            destination: paths.servicesInvite,
+                            importMapProviders: {
+                                authModuleImports,
+                                configServiceImports,
+                                errorHandlerServiceImports,
+                                passwordHasherServiceImports,
+                                prismaGeneratedImports,
+                                prismaImports,
+                                requestServiceContextImports,
+                                userSessionTypesImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
                 },
             },
         };