@baseplate-dev/plugin-auth 1.0.6 → 1.0.8

package/dist/better-auth/generators/fastify/better-auth-module/better-auth-module.generator.d.ts

@@ -0,0 +1,151 @@
+export declare const betterAuthModuleGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    devBackendPort: number;
+    devWebDomainPort: number;
+    devWebPorts?: number[] | undefined;
+}, {
+    paths: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthModulePaths: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-paths.js").BetterAuthBetterAuthModulePaths>;
+    }, {
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+    }, undefined>;
+    imports: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            Auth: {
+                isTypeOnly: true;
+            };
+            AuthServiceDeps: {
+                isTypeOnly: true;
+            };
+            betterAuthPlugin: {};
+            buildAuth: {};
+            cookiePrefix: {};
+            createBetterAuthUserSessionService: {};
+            toWebHeaders: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthModulePaths>;
+    }, undefined>;
+    renderers: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthModuleRenderers: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-renderers.js").BetterAuthBetterAuthModuleRenderers>;
+    }, {
+        appRuntimeImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AppRuntime: {
+                isTypeOnly: true;
+            };
+            AppServices: {
+                isTypeOnly: true;
+            };
+            createAppRuntime: {};
+            InternalServices: {
+                isTypeOnly: true;
+            };
+            RuntimeServices: {
+                isTypeOnly: true;
+            };
+        }>>;
+        authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthContext: {
+                isTypeOnly: true;
+            };
+            AuthSessionInfo: {
+                isTypeOnly: true;
+            };
+            AuthUserSessionInfo: {
+                isTypeOnly: true;
+            };
+            createAnonymousAuthContext: {};
+            createAuthContextFromSessionInfo: {};
+            createSystemAuthContext: {};
+            InvalidSessionError: {};
+        }>>;
+        authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AUTH_ROLE_CONFIG: {};
+            AuthRole: {
+                isTypeOnly: true;
+            };
+            DEFAULT_PUBLIC_ROLES: {};
+            DEFAULT_USER_ROLES: {};
+            RoleConfig: {
+                isTypeOnly: true;
+            };
+        }>>;
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            getConfig: {};
+            isDevelopment: {};
+        }>>;
+        emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createEmailService: {};
+            createEmailTransport: {};
+            EmailAdapter: {
+                isTypeOnly: true;
+            };
+            EmailAttachment: {
+                isTypeOnly: true;
+            };
+            EmailRawOptions: {
+                isTypeOnly: true;
+            };
+            EmailSendOptions: {
+                isTypeOnly: true;
+            };
+            EmailService: {
+                isTypeOnly: true;
+            };
+            EmailTransport: {
+                isTypeOnly: true;
+            };
+            sendEmailQueue: {};
+            sendEmailWorker: {};
+            TransformedEmailMessage: {
+                isTypeOnly: true;
+            };
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthModulePaths>;
+        pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            builder: {};
+        }>>;
+        prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            prisma: {};
+        }>>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            UserSessionPayload: {
+                isTypeOnly: true;
+            };
+            UserSessionService: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, undefined>;
+    config: import("@baseplate-dev/sync").GeneratorTask<undefined, {
+        provider: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            configFields: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/fastify-generators").ConfigServiceField>;
+        }>, "getValues">>;
+    }, undefined>;
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        prismaOutput: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").PrismaOutputProvider>;
+        renderers: import("@baseplate-dev/sync").ProviderType<import("./generated/template-renderers.js").BetterAuthBetterAuthModuleRenderers>;
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthModulePaths>;
+        transactionalLibConfig: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/plugin-email").TransactionalLibConfigProvider>;
+    }, any>;
+    appRuntimeConfig: import("@baseplate-dev/sync").GeneratorTask<any, {
+        appRuntimeConfig: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            services: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/fastify-generators").AppRuntimeServiceEntry>;
+            construction: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/fastify-generators").AppRuntimeConstructionEntry>;
+            flattenedModuleFields: import("@baseplate-dev/utils").MapContainer<string, string>;
+            usesBackgroundServices: import("@baseplate-dev/utils").ScalarContainer<boolean | undefined>;
+        }>, "getValues">>;
+        userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            UserSessionPayload: {
+                isTypeOnly: true;
+            };
+            UserSessionService: {
+                isTypeOnly: true;
+            };
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthModulePaths>;
+    }, any>;
+    nodePackages: import("@baseplate-dev/sync").AnyGeneratorTask;
+}>;
+//# sourceMappingURL=better-auth-module.generator.d.ts.map

package/dist/better-auth/generators/fastify/better-auth-module/better-auth-module.generator.js

@@ -0,0 +1,109 @@
+import { createNodePackagesTask, extractPackageVersions, tsCodeFragment, TsCodeUtils, tsImportBuilder, tsTypeImportBuilder, } from '@baseplate-dev/core-generators';
+import { appModuleProvider, appRuntimeConfigProvider, configServiceProvider, prismaOutputProvider, userSessionTypesImportsProvider, } from '@baseplate-dev/fastify-generators';
+import { transactionalLibConfigProvider } from '@baseplate-dev/plugin-email';
+import { createGenerator, createGeneratorTask, createProviderTask, } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { BETTER_AUTH_MODELS } from '#src/better-auth/constants/model-names.js';
+import { BETTER_AUTH_PACKAGES } from '#src/better-auth/constants/packages.js';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED } from './generated/index.js';
+const descriptorSchema = z.object({
+    devWebPorts: z.array(z.number()).default([]),
+    devBackendPort: z.number(),
+    devWebDomainPort: z.number(),
+});
+export const betterAuthModuleGenerator = createGenerator({
+    name: 'better-auth/better-auth-module',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: ({ devWebPorts, devBackendPort, devWebDomainPort }) => ({
+        paths: BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED.paths.task,
+        imports: BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED.imports.task,
+        renderers: BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED.renderers.task,
+        config: createProviderTask(configServiceProvider, (configService) => {
+            const betterAuthSecret = 'dev-secret-change-me-in-production';
+            configService.configFields.set('BETTER_AUTH_SECRET', {
+                validator: tsCodeFragment('z.string().min(32)'),
+                comment: 'Better Auth secret key for signing sessions',
+                seedValue: betterAuthSecret,
+                exampleValue: betterAuthSecret,
+            });
+            const betterAuthUrl = `http://localhost:${String(devBackendPort)}`;
+            configService.configFields.set('BETTER_AUTH_URL', {
+                validator: tsCodeFragment('z.url()'),
+                comment: 'Better Auth base URL (backend server URL)',
+                seedValue: betterAuthUrl,
+                exampleValue: betterAuthUrl,
+            });
+            const allowedOrigins = devWebPorts
+                .map((p) => `http://localhost:${String(p)}`)
+                .join(',');
+            configService.configFields.set('ALLOWED_ORIGINS', {
+                validator: tsCodeFragment('z.string().default("")'),
+                comment: 'Comma-separated list of allowed CORS origins (e.g. https://example.com,https://app.example.com)',
+                seedValue: allowedOrigins,
+                exampleValue: allowedOrigins,
+            });
+            configService.configFields.set('AUTH_FRONTEND_URL', {
+                validator: tsCodeFragment('z.url()'),
+                comment: 'Frontend URL for authentication flows including password reset and email verification (e.g., https://app.example.com)',
+                exampleValue: `http://localhost:${devWebDomainPort}`,
+            });
+        }),
+        main: createGeneratorTask({
+            dependencies: {
+                prismaOutput: prismaOutputProvider,
+                renderers: BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED.renderers.provider,
+                appModule: appModuleProvider,
+                paths: BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED.paths.provider,
+                transactionalLibConfig: transactionalLibConfigProvider,
+            },
+            run({ prismaOutput, renderers, appModule, paths, transactionalLibConfig, }) {
+                const transactionalLibPackageName = transactionalLibConfig.getTransactionalLibPackageName();
+                appModule.moduleFields.set('plugins', 'betterAuthPlugin', tsCodeFragment('betterAuthPlugin', tsImportBuilder(['betterAuthPlugin']).from(paths.betterAuthPlugin)));
+                appModule.moduleImports.push(paths.userSessionQueries);
+                return {
+                    build: async (builder) => {
+                        await builder.apply(renderers.auth.render({
+                            variables: {
+                                TPL_USER_ROLE_MODEL: prismaOutput.getPrismaModelFragment(BETTER_AUTH_MODELS.userRole),
+                                TPL_PASSWORD_RESET_EMAIL: TsCodeUtils.importFragment('PasswordResetEmail', transactionalLibPackageName),
+                                TPL_ACCOUNT_VERIFICATION_EMAIL: TsCodeUtils.importFragment('AccountVerificationEmail', transactionalLibPackageName),
+                            },
+                        }));
+                        await builder.apply(renderers.userSessionService.render({}));
+                        await builder.apply(renderers.userSessionQueries.render({}));
+                        await builder.apply(renderers.betterAuthPlugin.render({}));
+                        await builder.apply(renderers.headersUtils.render({}));
+                    },
+                };
+            },
+        }),
+        appRuntimeConfig: createGeneratorTask({
+            dependencies: {
+                appRuntimeConfig: appRuntimeConfigProvider,
+                userSessionTypesImports: userSessionTypesImportsProvider,
+                paths: BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED.paths.provider,
+            },
+            run({ appRuntimeConfig, userSessionTypesImports, paths }) {
+                appRuntimeConfig.services.set('betterAuth', {
+                    type: tsCodeFragment('Auth', tsTypeImportBuilder(['Auth']).from(paths.auth)),
+                });
+                appRuntimeConfig.services.set('userSession', {
+                    type: userSessionTypesImports.UserSessionService.typeFragment(),
+                });
+                appRuntimeConfig.construction.set('betterAuth', {
+                    dependencies: ['email'],
+                    fragment: TsCodeUtils.template `${TsCodeUtils.importFragment('buildAuth', paths.auth)}({ email })`,
+                });
+                appRuntimeConfig.construction.set('userSession', {
+                    dependencies: ['betterAuth'],
+                    fragment: TsCodeUtils.template `${TsCodeUtils.importFragment('createBetterAuthUserSessionService', paths.userSessionService)}(betterAuth)`,
+                });
+            },
+        }),
+        nodePackages: createNodePackagesTask({
+            prod: extractPackageVersions(BETTER_AUTH_PACKAGES, ['better-auth']),
+        }),
+    }),
+});
+//# sourceMappingURL=better-auth-module.generator.js.map

package/dist/better-auth/generators/fastify/better-auth-module/generated/index.d.ts

@@ -0,0 +1,234 @@
+export declare const BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED: {
+    imports: {
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            betterAuthModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                Auth: {
+                    isTypeOnly: true;
+                };
+                AuthServiceDeps: {
+                    isTypeOnly: true;
+                };
+                betterAuthPlugin: {};
+                buildAuth: {};
+                cookiePrefix: {};
+                createBetterAuthUserSessionService: {};
+                toWebHeaders: {};
+            }>>;
+        }, {
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").BetterAuthBetterAuthModulePaths>;
+        }, undefined>;
+    };
+    paths: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").BetterAuthBetterAuthModulePaths>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            betterAuthBetterAuthModulePaths: import("@baseplate-dev/sync").ProviderExport<import("./template-paths.js").BetterAuthBetterAuthModulePaths>;
+        }, {
+            appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+        }, undefined>;
+    };
+    renderers: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-renderers.js").BetterAuthBetterAuthModuleRenderers>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            betterAuthBetterAuthModuleRenderers: import("@baseplate-dev/sync").ProviderExport<import("./template-renderers.js").BetterAuthBetterAuthModuleRenderers>;
+        }, {
+            appRuntimeImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AppRuntime: {
+                    isTypeOnly: true;
+                };
+                AppServices: {
+                    isTypeOnly: true;
+                };
+                createAppRuntime: {};
+                InternalServices: {
+                    isTypeOnly: true;
+                };
+                RuntimeServices: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AuthContext: {
+                    isTypeOnly: true;
+                };
+                AuthSessionInfo: {
+                    isTypeOnly: true;
+                };
+                AuthUserSessionInfo: {
+                    isTypeOnly: true;
+                };
+                createAnonymousAuthContext: {};
+                createAuthContextFromSessionInfo: {};
+                createSystemAuthContext: {};
+                InvalidSessionError: {};
+            }>>;
+            authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AUTH_ROLE_CONFIG: {};
+                AuthRole: {
+                    isTypeOnly: true;
+                };
+                DEFAULT_PUBLIC_ROLES: {};
+                DEFAULT_USER_ROLES: {};
+                RoleConfig: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                getConfig: {};
+                isDevelopment: {};
+            }>>;
+            emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createEmailService: {};
+                createEmailTransport: {};
+                EmailAdapter: {
+                    isTypeOnly: true;
+                };
+                EmailAttachment: {
+                    isTypeOnly: true;
+                };
+                EmailRawOptions: {
+                    isTypeOnly: true;
+                };
+                EmailSendOptions: {
+                    isTypeOnly: true;
+                };
+                EmailService: {
+                    isTypeOnly: true;
+                };
+                EmailTransport: {
+                    isTypeOnly: true;
+                };
+                sendEmailQueue: {};
+                sendEmailWorker: {};
+                TransformedEmailMessage: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").BetterAuthBetterAuthModulePaths>;
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+            prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                prisma: {};
+            }>>;
+            typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+            userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionPayload: {
+                    isTypeOnly: true;
+                };
+                UserSessionService: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, undefined>;
+    };
+    templates: {
+        auth: import("@baseplate-dev/core-generators").TsTemplateFile<{
+            TPL_ACCOUNT_VERIFICATION_EMAIL: {};
+            TPL_PASSWORD_RESET_EMAIL: {};
+            TPL_USER_ROLE_MODEL: {};
+        }, {
+            authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AUTH_ROLE_CONFIG: {};
+                AuthRole: {
+                    isTypeOnly: true;
+                };
+                DEFAULT_PUBLIC_ROLES: {};
+                DEFAULT_USER_ROLES: {};
+                RoleConfig: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                getConfig: {};
+                isDevelopment: {};
+            }>>;
+            emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createEmailService: {};
+                createEmailTransport: {};
+                EmailAdapter: {
+                    isTypeOnly: true;
+                };
+                EmailAttachment: {
+                    isTypeOnly: true;
+                };
+                EmailRawOptions: {
+                    isTypeOnly: true;
+                };
+                EmailSendOptions: {
+                    isTypeOnly: true;
+                };
+                EmailService: {
+                    isTypeOnly: true;
+                };
+                EmailTransport: {
+                    isTypeOnly: true;
+                };
+                sendEmailQueue: {};
+                sendEmailWorker: {};
+                TransformedEmailMessage: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                prisma: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+        betterAuthPlugin: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            appRuntimeImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AppRuntime: {
+                    isTypeOnly: true;
+                };
+                AppServices: {
+                    isTypeOnly: true;
+                };
+                createAppRuntime: {};
+                InternalServices: {
+                    isTypeOnly: true;
+                };
+                RuntimeServices: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, {
+            headersUtils: {};
+        }>;
+        headersUtils: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+        userSessionQueries: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+            prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                prisma: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+        userSessionService: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AuthContext: {
+                    isTypeOnly: true;
+                };
+                AuthSessionInfo: {
+                    isTypeOnly: true;
+                };
+                AuthUserSessionInfo: {
+                    isTypeOnly: true;
+                };
+                createAnonymousAuthContext: {};
+                createAuthContextFromSessionInfo: {};
+                createSystemAuthContext: {};
+                InvalidSessionError: {};
+            }>>;
+            userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionPayload: {
+                    isTypeOnly: true;
+                };
+                UserSessionService: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, {
+            auth: {};
+            headersUtils: {};
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/generators/fastify/better-auth-module/generated/index.js

@@ -0,0 +1,11 @@
+import { BETTER_AUTH_BETTER_AUTH_MODULE_PATHS } from './template-paths.js';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_RENDERERS } from './template-renderers.js';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_IMPORTS } from './ts-import-providers.js';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES } from './typed-templates.js';
+export const BETTER_AUTH_BETTER_AUTH_MODULE_GENERATED = {
+    imports: BETTER_AUTH_BETTER_AUTH_MODULE_IMPORTS,
+    paths: BETTER_AUTH_BETTER_AUTH_MODULE_PATHS,
+    renderers: BETTER_AUTH_BETTER_AUTH_MODULE_RENDERERS,
+    templates: BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES,
+};
+//# sourceMappingURL=index.js.map

package/dist/better-auth/generators/fastify/better-auth-module/generated/template-paths.d.ts

@@ -0,0 +1,16 @@
+export interface BetterAuthBetterAuthModulePaths {
+    auth: string;
+    betterAuthPlugin: string;
+    headersUtils: string;
+    userSessionQueries: string;
+    userSessionService: string;
+}
+export declare const BETTER_AUTH_BETTER_AUTH_MODULE_PATHS: {
+    provider: import("@baseplate-dev/sync").ProviderType<BetterAuthBetterAuthModulePaths>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthModulePaths: import("@baseplate-dev/sync").ProviderExport<BetterAuthBetterAuthModulePaths>;
+    }, {
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+    }, undefined>;
+};
+//# sourceMappingURL=template-paths.d.ts.map

package/dist/better-auth/generators/fastify/better-auth-module/generated/template-paths.js

@@ -0,0 +1,28 @@
+import { appModuleProvider } from '@baseplate-dev/fastify-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+const betterAuthBetterAuthModulePaths = createProviderType('better-auth-better-auth-module-paths');
+const betterAuthBetterAuthModulePathsTask = createGeneratorTask({
+    dependencies: { appModule: appModuleProvider },
+    exports: {
+        betterAuthBetterAuthModulePaths: betterAuthBetterAuthModulePaths.export(),
+    },
+    run({ appModule }) {
+        const moduleRoot = appModule.getModuleFolder();
+        return {
+            providers: {
+                betterAuthBetterAuthModulePaths: {
+                    auth: `${moduleRoot}/services/auth.ts`,
+                    betterAuthPlugin: `${moduleRoot}/plugins/better-auth.plugin.ts`,
+                    headersUtils: `${moduleRoot}/utils/headers.utils.ts`,
+                    userSessionQueries: `${moduleRoot}/schema/user-session.queries.ts`,
+                    userSessionService: `${moduleRoot}/services/user-session.service.ts`,
+                },
+            },
+        };
+    },
+});
+export const BETTER_AUTH_BETTER_AUTH_MODULE_PATHS = {
+    provider: betterAuthBetterAuthModulePaths,
+    task: betterAuthBetterAuthModulePathsTask,
+};
+//# sourceMappingURL=template-paths.js.map

package/dist/better-auth/generators/fastify/better-auth-module/generated/template-renderers.d.ts

@@ -0,0 +1,116 @@
+import type { RenderTsTemplateFileActionInput } from '@baseplate-dev/core-generators';
+import type { BuilderAction } from '@baseplate-dev/sync';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES } from './typed-templates.js';
+export interface BetterAuthBetterAuthModuleRenderers {
+    auth: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.auth>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    betterAuthPlugin: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.betterAuthPlugin>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    headersUtils: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.headersUtils>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    userSessionQueries: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.userSessionQueries>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    userSessionService: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.userSessionService>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+}
+export declare const BETTER_AUTH_BETTER_AUTH_MODULE_RENDERERS: {
+    provider: import("@baseplate-dev/sync").ProviderType<BetterAuthBetterAuthModuleRenderers>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthModuleRenderers: import("@baseplate-dev/sync").ProviderExport<BetterAuthBetterAuthModuleRenderers>;
+    }, {
+        appRuntimeImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AppRuntime: {
+                isTypeOnly: true;
+            };
+            AppServices: {
+                isTypeOnly: true;
+            };
+            createAppRuntime: {};
+            InternalServices: {
+                isTypeOnly: true;
+            };
+            RuntimeServices: {
+                isTypeOnly: true;
+            };
+        }>>;
+        authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthContext: {
+                isTypeOnly: true;
+            };
+            AuthSessionInfo: {
+                isTypeOnly: true;
+            };
+            AuthUserSessionInfo: {
+                isTypeOnly: true;
+            };
+            createAnonymousAuthContext: {};
+            createAuthContextFromSessionInfo: {};
+            createSystemAuthContext: {};
+            InvalidSessionError: {};
+        }>>;
+        authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AUTH_ROLE_CONFIG: {};
+            AuthRole: {
+                isTypeOnly: true;
+            };
+            DEFAULT_PUBLIC_ROLES: {};
+            DEFAULT_USER_ROLES: {};
+            RoleConfig: {
+                isTypeOnly: true;
+            };
+        }>>;
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            getConfig: {};
+            isDevelopment: {};
+        }>>;
+        emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createEmailService: {};
+            createEmailTransport: {};
+            EmailAdapter: {
+                isTypeOnly: true;
+            };
+            EmailAttachment: {
+                isTypeOnly: true;
+            };
+            EmailRawOptions: {
+                isTypeOnly: true;
+            };
+            EmailSendOptions: {
+                isTypeOnly: true;
+            };
+            EmailService: {
+                isTypeOnly: true;
+            };
+            EmailTransport: {
+                isTypeOnly: true;
+            };
+            sendEmailQueue: {};
+            sendEmailWorker: {};
+            TransformedEmailMessage: {
+                isTypeOnly: true;
+            };
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").BetterAuthBetterAuthModulePaths>;
+        pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            builder: {};
+        }>>;
+        prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            prisma: {};
+        }>>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            UserSessionPayload: {
+                isTypeOnly: true;
+            };
+            UserSessionService: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, undefined>;
+};
+//# sourceMappingURL=template-renderers.d.ts.map