@baseplate-dev/plugin-auth 1.0.7 → 1.0.8

package/dist/better-auth/core/common.js

@@ -1,17 +1,20 @@
-import { authModelsSpec, createPluginModule, pluginConfigSpec, } from '@baseplate-dev/project-builder-lib';
+import { authModelsSpec, createPluginModule, definitionIssueCheckerSpec, pluginConfigSpec, } from '@baseplate-dev/project-builder-lib';
 import { BETTER_AUTH_MODELS } from '../constants/model-names.js';
 import { createBetterAuthPluginDefinitionSchema } from './schema/plugin-definition.js';
+import { createBetterAuthSchemaChecker } from './schema/schema-issue-checker.js';
 export default createPluginModule({
     name: 'common',
     dependencies: {
         pluginConfig: pluginConfigSpec,
         authModels: authModelsSpec,
+        issueCheckers: definitionIssueCheckerSpec,
     },
-    initialize: ({ pluginConfig, authModels }, { pluginKey }) => {
+    initialize: ({ pluginConfig, authModels, issueCheckers }, { pluginKey }) => {
         pluginConfig.schemas.set(pluginKey, createBetterAuthPluginDefinitionSchema);
         authModels.getAuthModels.set(() => ({
             user: BETTER_AUTH_MODELS.user,
         }));
+        issueCheckers.checkers.set(pluginKey, createBetterAuthSchemaChecker(pluginKey));
     },
 });
 //# sourceMappingURL=common.js.map

package/dist/better-auth/core/components/better-auth-definition-editor.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { applyMergedDefinition, diffDefinition, PluginUtils, } from '@baseplate-dev/project-builder-lib';
 import { DefinitionDiffAlert, useBlockUnsavedChangesNavigate, useDefinitionSchema, useProjectDefinition, useResettableForm, } from '@baseplate-dev/project-builder-lib/web';
-import { FormActionBar, SectionList, SectionListSection, SectionListSectionContent, SectionListSectionDescription, SectionListSectionHeader, SectionListSectionTitle, } from '@baseplate-dev/ui-components';
+import { FormActionBar, MultiComboboxFieldController, SectionList, SectionListSection, SectionListSectionContent, SectionListSectionDescription, SectionListSectionHeader, SectionListSectionTitle, } from '@baseplate-dev/ui-components';
 import { zodResolver } from '@hookform/resolvers/zod';
 import { useMemo } from 'react';
 import { getAuthPluginDefinition } from '#src/auth/utils/get-auth-plugin-definition.js';
@@ -12,23 +12,35 @@ import '#src/styles.css';
 export function BetterAuthDefinitionEditor({ definition: pluginMetadata, metadata, onSave, }) {
     const { definition, definitionContainer, saveDefinitionWithFeedback } = useProjectDefinition();
     const betterAuthPluginDefinitionSchema = useDefinitionSchema(createBetterAuthPluginDefinitionSchema);
+    const authDefinition = getAuthPluginDefinition(definition);
+    const roles = authDefinition.roles
+        .filter((role) => !role.builtIn)
+        .map((role) => ({
+        label: role.name,
+        value: role.id,
+    }));
     const defaultValues = useMemo(() => {
         if (pluginMetadata?.config) {
             return pluginMetadata.config;
         }
-        return {};
+        return {
+            additionalUserAdminRoles: [],
+        };
     }, [pluginMetadata?.config]);
     const form = useResettableForm({
         resolver: zodResolver(betterAuthPluginDefinitionSchema),
         defaultValues,
     });
     const { control, reset, handleSubmit } = form;
-    const authDefinition = getAuthPluginDefinition(definition);
     const authFeature = definition.features.find((f) => f.id === authDefinition.authFeatureRef);
     if (!authFeature) {
         throw new Error(`Auth feature not found for ref: ${authDefinition.authFeatureRef}`);
     }
-    const partialDef = useMemo(() => createBetterAuthPartialDefinition(authFeature.name), [authFeature.name]);
+    const accountsFeature = definition.features.find((f) => f.id === authDefinition.accountsFeatureRef);
+    if (!accountsFeature) {
+        throw new Error(`Accounts feature not found for ref: ${authDefinition.accountsFeatureRef}`);
+    }
+    const partialDef = useMemo(() => createBetterAuthPartialDefinition(authFeature.name, accountsFeature.name), [authFeature.name, accountsFeature.name]);
     const diff = useMemo(() => diffDefinition(definitionContainer.schema, definitionContainer.definition, partialDef), [definitionContainer, partialDef]);
     const onSubmit = handleSubmit((data) => saveDefinitionWithFeedback((draftConfig) => {
         const updatedData = {
@@ -45,6 +57,6 @@ export function BetterAuthDefinitionEditor({ definition: pluginMetadata, metadat
     useBlockUnsavedChangesNavigate({ control, reset, onSubmit });
     return (_jsxs("div", { className: "auth:relative auth:flex auth:h-full auth:flex-1 auth:flex-col auth:gap-4 auth:overflow-hidden", children: [_jsx(AuthConfigTabs, {}), _jsx("div", { className: "auth:mb-[--action-bar-height] auth:flex auth:flex-1 auth:overflow-y-auto", style: {
                     '--action-bar-height': '52px',
-                }, children: _jsxs("form", { onSubmit: onSubmit, className: "auth:max-w-6xl auth:flex-1", children: [_jsx("div", { className: "auth:pb-16", children: _jsx(SectionList, { children: _jsxs(SectionListSection, { children: [_jsxs(SectionListSectionHeader, { children: [_jsx(SectionListSectionTitle, { children: "Better Auth Configuration" }), _jsx(SectionListSectionDescription, { children: "The plugin will automatically configure the models it needs." })] }), _jsx(SectionListSectionContent, { className: "auth:space-y-6", children: _jsx(DefinitionDiffAlert, { diff: diff, upToDateMessage: "All required models are already configured correctly. No changes needed." }) })] }) }) }), _jsx(FormActionBar, { form: form, allowSaveWithoutDirty: !pluginMetadata || diff.hasChanges })] }) })] }));
+                }, children: _jsxs("form", { onSubmit: onSubmit, className: "auth:max-w-6xl auth:flex-1", children: [_jsx("div", { className: "auth:pb-16", children: _jsxs(SectionList, { children: [_jsxs(SectionListSection, { children: [_jsxs(SectionListSectionHeader, { children: [_jsx(SectionListSectionTitle, { children: "Better Auth Configuration" }), _jsx(SectionListSectionDescription, { children: "The plugin will automatically configure the models it needs." })] }), _jsx(SectionListSectionContent, { className: "auth:space-y-6", children: _jsx(DefinitionDiffAlert, { diff: diff, upToDateMessage: "All required models are already configured correctly. No changes needed." }) })] }), _jsxs(SectionListSection, { children: [_jsxs(SectionListSectionHeader, { children: [_jsx(SectionListSectionTitle, { children: "User Management Permissions" }), _jsx(SectionListSectionDescription, { children: "The \"admin\" role always has user management permissions. Optionally add more roles that can manage users and assign roles in the admin interface." })] }), _jsx(SectionListSectionContent, { className: "auth:space-y-6", children: _jsx(MultiComboboxFieldController, { label: "Additional User Admin Roles", name: "additionalUserAdminRoles", control: control, options: roles, description: "Additional roles (beyond admin) that can manage users and assign roles." }) })] })] }) }), _jsx(FormActionBar, { form: form, allowSaveWithoutDirty: !pluginMetadata || diff.hasChanges })] }) })] }));
 }
 //# sourceMappingURL=better-auth-definition-editor.js.map

package/dist/better-auth/core/node.js

@@ -1,25 +1,42 @@
-import { appCompilerSpec, backendAppEntryType, createPluginModule, pluginAppCompiler, webAppEntryType, } from '@baseplate-dev/project-builder-lib';
+import { emailTemplateSpec } from '@baseplate-dev/plugin-email';
+import { appCompilerSpec, backendAppEntryType, createPluginModule, pluginAppCompiler, PluginUtils, webAppEntryType, } from '@baseplate-dev/project-builder-lib';
 import { reactRoutesGenerator } from '@baseplate-dev/react-generators';
 import { getAuthPluginDefinition } from '#src/auth/utils/get-auth-plugin-definition.js';
-import { betterAuthHooksGenerator, betterAuthModuleGenerator, betterAuthPagesGenerator, reactBetterAuthGenerator, } from '../generators/index.js';
+import { betterAuthAdminModuleGenerator, betterAuthEmailTemplatesGenerator, betterAuthHooksGenerator, betterAuthModuleGenerator, betterAuthPagesGenerator, betterAuthSeedInitialUserGenerator, reactBetterAuthGenerator, } from '../generators/index.js';
 export default createPluginModule({
     name: 'node',
     dependencies: {
         appCompiler: appCompilerSpec,
+        emailTemplate: emailTemplateSpec,
     },
-    initialize: ({ appCompiler }, { pluginKey }) => {
+    initialize: ({ appCompiler, emailTemplate }, { pluginKey }) => {
+        // Register auth email templates with the transactional lib
+        emailTemplate.generators.push(betterAuthEmailTemplatesGenerator({}));
         appCompiler.compilers.push(pluginAppCompiler({
             pluginKey,
             appType: backendAppEntryType,
-            compile: ({ projectDefinition, appDefinition, appCompiler }) => {
+            compile: ({ projectDefinition, appDefinition, appCompiler, definitionContainer, }) => {
                 const auth = getAuthPluginDefinition(projectDefinition);
+                const betterAuthDefinition = PluginUtils.configByKeyOrThrow(projectDefinition, pluginKey);
                 // Get web app ports
                 const webApps = projectDefinition.apps.filter((app) => app.type === 'web');
                 const devWebPorts = webApps.map((app) => app.devPort);
+                const devWebDomainPort = devWebPorts[0] ??
+                    projectDefinition.settings.general.portOffset + 30;
+                const additionalAdminRoles = betterAuthDefinition.additionalUserAdminRoles.map((role) => definitionContainer.nameFromId(role));
+                // 'admin' is always included since it is now a built-in role guaranteed to exist
+                const adminRoles = [...new Set(['admin', ...additionalAdminRoles])];
                 appCompiler.addChildrenToFeature(auth.authFeatureRef, {
+                    seedInitialUser: betterAuthSeedInitialUserGenerator({
+                        initialUserRoles: ['admin'],
+                    }),
                     betterAuthModule: betterAuthModuleGenerator({
                         devWebPorts,
                         devBackendPort: appDefinition.devPort,
+                        devWebDomainPort,
+                    }),
+                    betterAuthAdminModule: betterAuthAdminModuleGenerator({
+                        adminRoles,
                     }),
                 });
             },

package/dist/better-auth/core/schema/models.d.ts

@@ -1,3 +1,3 @@
 import type { PartialProjectDefinitionInput } from '@baseplate-dev/project-builder-lib';
-export declare function createBetterAuthPartialDefinition(authFeatureName: string): PartialProjectDefinitionInput;
+export declare function createBetterAuthPartialDefinition(authFeatureName: string, accountsFeatureName: string): PartialProjectDefinitionInput;
 //# sourceMappingURL=models.d.ts.map

package/dist/better-auth/core/schema/models.js

@@ -1,16 +1,16 @@
 import { BETTER_AUTH_MODELS } from '#src/better-auth/constants/model-names.js';
-export function createBetterAuthPartialDefinition(authFeatureName) {
+export function createBetterAuthPartialDefinition(authFeatureName, accountsFeatureName) {
     return {
         models: [
             {
                 name: BETTER_AUTH_MODELS.user,
-                featureRef: authFeatureName,
+                featureRef: accountsFeatureName,
                 model: {
                     fields: [
                         {
                             name: 'id',
                             type: 'uuid',
-                            options: { genUuid: true },
+                            options: { defaultGeneration: 'uuidv7' },
                         },
                         {
                             name: 'name',
@@ -53,19 +53,34 @@ export function createBetterAuthPartialDefinition(authFeatureName) {
                 graphql: {
                     objectType: {
                         enabled: true,
-                        fields: [{ ref: 'id' }, { ref: 'email' }],
+                        fields: [
+                            { ref: 'id' },
+                            {
+                                ref: 'email',
+                                globalRoles: ['admin'],
+                                instanceRoles: ['self'],
+                            },
+                        ],
                     },
                 },
+                authorizer: {
+                    roles: [
+                        {
+                            name: 'self',
+                            expression: 'model.id === userId',
+                        },
+                    ],
+                },
             },
             {
                 name: BETTER_AUTH_MODELS.session,
-                featureRef: authFeatureName,
+                featureRef: accountsFeatureName,
                 model: {
                     fields: [
                         {
                             name: 'id',
                             type: 'uuid',
-                            options: { genUuid: true },
+                            options: { defaultGeneration: 'uuidv7' },
                         },
                         {
                             name: 'expiresAt',
@@ -120,13 +135,13 @@ export function createBetterAuthPartialDefinition(authFeatureName) {
             },
             {
                 name: BETTER_AUTH_MODELS.account,
-                featureRef: authFeatureName,
+                featureRef: accountsFeatureName,
                 model: {
                     fields: [
                         {
                             name: 'id',
                             type: 'uuid',
-                            options: { genUuid: true },
+                            options: { defaultGeneration: 'uuidv7' },
                         },
                         {
                             name: 'accountId',
@@ -207,7 +222,7 @@ export function createBetterAuthPartialDefinition(authFeatureName) {
                         {
                             name: 'id',
                             type: 'uuid',
-                            options: { genUuid: true },
+                            options: { defaultGeneration: 'uuidv4' },
                         },
                         {
                             name: 'identifier',
@@ -237,7 +252,7 @@ export function createBetterAuthPartialDefinition(authFeatureName) {
             },
             {
                 name: BETTER_AUTH_MODELS.userRole,
-                featureRef: authFeatureName,
+                featureRef: accountsFeatureName,
                 model: {
                     fields: [
                         {

package/dist/better-auth/core/schema/plugin-definition.d.ts

@@ -1,5 +1,8 @@
 import type { def } from '@baseplate-dev/project-builder-lib';
 import { z } from 'zod';
-export declare const createBetterAuthPluginDefinitionSchema: (context: import("@baseplate-dev/project-builder-lib").DefinitionSchemaParserContext) => z.ZodObject<{}, z.core.$strip>;
+export declare const createBetterAuthPluginDefinitionSchema: (context: import("@baseplate-dev/project-builder-lib").DefinitionSchemaParserContext) => z.ZodObject<{
+    additionalUserAdminRoles: z.ZodPrefault<z.ZodArray<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>>;
+}, z.core.$strip>;
+export type BetterAuthPluginDefinition = def.InferOutput<typeof createBetterAuthPluginDefinitionSchema>;
 export type BetterAuthPluginDefinitionInput = def.InferInput<typeof createBetterAuthPluginDefinitionSchema>;
 //# sourceMappingURL=plugin-definition.d.ts.map

package/dist/better-auth/core/schema/plugin-definition.js

@@ -1,4 +1,9 @@
-import { definitionSchema } from '@baseplate-dev/project-builder-lib';
+import { authRoleEntityType, definitionSchema, } from '@baseplate-dev/project-builder-lib';
 import { z } from 'zod';
-export const createBetterAuthPluginDefinitionSchema = definitionSchema(() => z.object({}));
+export const createBetterAuthPluginDefinitionSchema = definitionSchema((ctx) => z.object({
+    additionalUserAdminRoles: ctx.withDefault(z.array(ctx.withRef({
+        type: authRoleEntityType,
+        onDelete: 'DELETE',
+    })), []),
+}));
 //# sourceMappingURL=plugin-definition.js.map

package/dist/better-auth/core/schema/schema-issue-checker.d.ts

@@ -0,0 +1,3 @@
+import type { DefinitionIssueChecker } from '@baseplate-dev/project-builder-lib';
+export declare function createBetterAuthSchemaChecker(pluginKey: string): DefinitionIssueChecker;
+//# sourceMappingURL=schema-issue-checker.d.ts.map

package/dist/better-auth/core/schema/schema-issue-checker.js

@@ -0,0 +1,21 @@
+import { createPluginModelSyncChecker, FeatureUtils, } from '@baseplate-dev/project-builder-lib';
+import { getAuthPluginDefinition } from '#src/auth/index.js';
+import { createBetterAuthPartialDefinition } from './models.js';
+export function createBetterAuthSchemaChecker(pluginKey) {
+    return createPluginModelSyncChecker({
+        pluginKey,
+        pluginLabel: 'Better Auth',
+        buildPartialDef: (container) => {
+            const authConfig = getAuthPluginDefinition(container.definition);
+            try {
+                const authFeatureName = FeatureUtils.getFeaturePathByIdOrThrow(container.definition, authConfig.authFeatureRef);
+                const accountsFeatureName = FeatureUtils.getFeaturePathByIdOrThrow(container.definition, authConfig.accountsFeatureRef);
+                return createBetterAuthPartialDefinition(authFeatureName, accountsFeatureName);
+            }
+            catch {
+                return undefined;
+            }
+        },
+    });
+}
+//# sourceMappingURL=schema-issue-checker.js.map

package/dist/better-auth/core/web.js

@@ -1,13 +1,26 @@
-import { createPluginModule, webConfigSpec, } from '@baseplate-dev/project-builder-lib';
+import { createPluginModule, FeatureUtils, pluginDefaultsSpec, webConfigSpec, } from '@baseplate-dev/project-builder-lib';
 import { BetterAuthDefinitionEditor } from './components/better-auth-definition-editor.js';
+import { createBetterAuthPartialDefinition } from './schema/models.js';
 import '../../styles.css';
+const AUTH_FEATURE_NAME = 'accounts/auth';
+const ACCOUNTS_FEATURE_NAME = 'accounts/users';
 export default createPluginModule({
     name: 'web',
     dependencies: {
         webConfig: webConfigSpec,
+        pluginDefaults: pluginDefaultsSpec,
     },
-    initialize: ({ webConfig }, { pluginKey }) => {
+    initialize: ({ webConfig, pluginDefaults }, { pluginKey }) => {
         webConfig.components.set(pluginKey, BetterAuthDefinitionEditor);
+        pluginDefaults.builders.set(pluginKey, ({ draft }) => {
+            // Idempotent with the parent auth builder, which also ensures these.
+            FeatureUtils.ensureFeatureByNameRecursively(draft, AUTH_FEATURE_NAME);
+            FeatureUtils.ensureFeatureByNameRecursively(draft, ACCOUNTS_FEATURE_NAME);
+            return {
+                config: {},
+                partialDef: createBetterAuthPartialDefinition(AUTH_FEATURE_NAME, ACCOUNTS_FEATURE_NAME),
+            };
+        });
     },
 });
 //# sourceMappingURL=web.js.map

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

@@ -0,0 +1,73 @@
+/**
+ * Generator for better-auth admin mutations.
+ *
+ * Adds GraphQL mutations for admin operations:
+ * - resetUserPassword: Allows admins to reset any user's password
+ * - updateUserRoles: Allows admins to manage user role assignments
+ */
+export declare const betterAuthAdminModuleGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    adminRoles: string[];
+}, {
+    paths: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthAdminModulePaths: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+    }, {
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators/src/index.js").AppModuleProvider>;
+    }, undefined>;
+    imports: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthAdminModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            resetUserPassword: {};
+            updateUserRoles: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+    }, undefined>;
+    renderers: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthAdminModuleRenderers: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-renderers.js").BetterAuthBetterAuthAdminModuleRenderers>;
+    }, {
+        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;
+            };
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            throwIfPrismaNotFound: {};
+            TooManyRequestsError: {};
+            UnauthorizedError: {};
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+        pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            builder: {};
+        }>>;
+        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: {};
+        }>>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+    }, undefined>;
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        renderers: import("@baseplate-dev/sync").ProviderType<import("./generated/template-renderers.js").BetterAuthBetterAuthAdminModuleRenderers>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators/src/index.js").AppModuleProvider>;
+        userObjectType: import("@baseplate-dev/sync").ProviderDependency<import("@baseplate-dev/fastify-generators/src/index.js").PothosTypeOutputProvider>;
+    }, any>;
+    nodePackages: import("@baseplate-dev/sync").AnyGeneratorTask;
+}>;
+//# sourceMappingURL=better-auth-admin-module.generator.d.ts.map

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

@@ -0,0 +1,56 @@
+import { createNodePackagesTask, extractPackageVersions, TsCodeUtils, } from '@baseplate-dev/core-generators';
+import { appModuleProvider, createPothosPrismaObjectTypeOutputName, pothosTypeOutputProvider, } from '@baseplate-dev/fastify-generators';
+import { createGenerator, createGeneratorTask } from '@baseplate-dev/sync';
+import { quot } from '@baseplate-dev/utils';
+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_ADMIN_MODULE_GENERATED } from './generated/index.js';
+const descriptorSchema = z.object({
+    adminRoles: z.array(z.string()),
+});
+/**
+ * Generator for better-auth admin mutations.
+ *
+ * Adds GraphQL mutations for admin operations:
+ * - resetUserPassword: Allows admins to reset any user's password
+ * - updateUserRoles: Allows admins to manage user role assignments
+ */
+export const betterAuthAdminModuleGenerator = createGenerator({
+    name: 'better-auth/better-auth-admin-module',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: ({ adminRoles }) => ({
+        paths: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_GENERATED.paths.task,
+        imports: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_GENERATED.imports.task,
+        renderers: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_GENERATED.renderers.task,
+        main: createGeneratorTask({
+            dependencies: {
+                renderers: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_GENERATED.renderers.provider,
+                paths: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_GENERATED.paths.provider,
+                appModule: appModuleProvider,
+                userObjectType: pothosTypeOutputProvider
+                    .dependency()
+                    .reference(createPothosPrismaObjectTypeOutputName(BETTER_AUTH_MODELS.user)),
+            },
+            run({ renderers, paths, appModule, userObjectType }) {
+                appModule.moduleImports.push(paths.adminAuthMutations);
+                return {
+                    build: async (builder) => {
+                        await builder.apply(renderers.adminAuthService.render({}));
+                        await builder.apply(renderers.adminAuthMutations.render({
+                            variables: {
+                                TPL_ADMIN_ROLES: TsCodeUtils.mergeFragmentsAsArrayPresorted(adminRoles.map((r) => quot(r)).toSorted()),
+                                TPL_USER_OBJECT_TYPE: userObjectType.getTypeReference().fragment,
+                            },
+                        }));
+                    },
+                };
+            },
+        }),
+        nodePackages: createNodePackagesTask({
+            prod: extractPackageVersions(BETTER_AUTH_PACKAGES, ['better-auth']),
+        }),
+    }),
+});
+//# sourceMappingURL=better-auth-admin-module.generator.js.map

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

@@ -0,0 +1,111 @@
+export declare const BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_GENERATED: {
+    imports: {
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            betterAuthAdminModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                resetUserPassword: {};
+                updateUserRoles: {};
+            }>>;
+        }, {
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+        }, undefined>;
+    };
+    paths: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            betterAuthBetterAuthAdminModulePaths: import("@baseplate-dev/sync").ProviderExport<import("./template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+        }, {
+            appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+        }, undefined>;
+    };
+    renderers: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-renderers.js").BetterAuthBetterAuthAdminModuleRenderers>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            betterAuthBetterAuthAdminModuleRenderers: import("@baseplate-dev/sync").ProviderExport<import("./template-renderers.js").BetterAuthBetterAuthAdminModuleRenderers>;
+        }, {
+            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;
+                };
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                throwIfPrismaNotFound: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+            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: {};
+            }>>;
+            typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        }, undefined>;
+    };
+    templates: {
+        adminAuthMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{
+            TPL_ADMIN_ROLES: {};
+            TPL_USER_OBJECT_TYPE: {};
+        }, {
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+        }, {
+            adminAuthService: {};
+        }>;
+        adminAuthService: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            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;
+                };
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                throwIfPrismaNotFound: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            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: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+import { BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_PATHS } from './template-paths.js';
+import { BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_RENDERERS } from './template-renderers.js';
+import { BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_IMPORTS } from './ts-import-providers.js';
+import { BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_TEMPLATES } from './typed-templates.js';
+export const BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_GENERATED = {
+    imports: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_IMPORTS,
+    paths: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_PATHS,
+    renderers: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_RENDERERS,
+    templates: BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_TEMPLATES,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,13 @@
+export interface BetterAuthBetterAuthAdminModulePaths {
+    adminAuthMutations: string;
+    adminAuthService: string;
+}
+export declare const BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_PATHS: {
+    provider: import("@baseplate-dev/sync").ProviderType<BetterAuthBetterAuthAdminModulePaths>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthAdminModulePaths: import("@baseplate-dev/sync").ProviderExport<BetterAuthBetterAuthAdminModulePaths>;
+    }, {
+        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-admin-module/generated/template-paths.js

@@ -0,0 +1,25 @@
+import { appModuleProvider } from '@baseplate-dev/fastify-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+const betterAuthBetterAuthAdminModulePaths = createProviderType('better-auth-better-auth-admin-module-paths');
+const betterAuthBetterAuthAdminModulePathsTask = createGeneratorTask({
+    dependencies: { appModule: appModuleProvider },
+    exports: {
+        betterAuthBetterAuthAdminModulePaths: betterAuthBetterAuthAdminModulePaths.export(),
+    },
+    run({ appModule }) {
+        const moduleRoot = appModule.getModuleFolder();
+        return {
+            providers: {
+                betterAuthBetterAuthAdminModulePaths: {
+                    adminAuthMutations: `${moduleRoot}/schema/admin-auth.mutations.ts`,
+                    adminAuthService: `${moduleRoot}/services/admin-auth.service.ts`,
+                },
+            },
+        };
+    },
+});
+export const BETTER_AUTH_BETTER_AUTH_ADMIN_MODULE_PATHS = {
+    provider: betterAuthBetterAuthAdminModulePaths,
+    task: betterAuthBetterAuthAdminModulePathsTask,
+};
+//# sourceMappingURL=template-paths.js.map