@baseplate-dev/plugin-auth 1.0.6 → 1.0.8

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

@@ -0,0 +1,91 @@
+import { typescriptFileProvider } from '@baseplate-dev/core-generators';
+import { appRuntimeImportsProvider, authContextImportsProvider, authRolesImportsProvider, configServiceImportsProvider, pothosImportsProvider, prismaImportsProvider, userSessionTypesImportsProvider, } from '@baseplate-dev/fastify-generators';
+import { emailModuleImportsProvider } from '@baseplate-dev/plugin-email';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_PATHS } from './template-paths.js';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES } from './typed-templates.js';
+const betterAuthBetterAuthModuleRenderers = createProviderType('better-auth-better-auth-module-renderers');
+const betterAuthBetterAuthModuleRenderersTask = createGeneratorTask({
+    dependencies: {
+        appRuntimeImports: appRuntimeImportsProvider,
+        authContextImports: authContextImportsProvider,
+        authRolesImports: authRolesImportsProvider,
+        configServiceImports: configServiceImportsProvider,
+        emailModuleImports: emailModuleImportsProvider,
+        paths: BETTER_AUTH_BETTER_AUTH_MODULE_PATHS.provider,
+        pothosImports: pothosImportsProvider,
+        prismaImports: prismaImportsProvider,
+        typescriptFile: typescriptFileProvider,
+        userSessionTypesImports: userSessionTypesImportsProvider,
+    },
+    exports: {
+        betterAuthBetterAuthModuleRenderers: betterAuthBetterAuthModuleRenderers.export(),
+    },
+    run({ appRuntimeImports, authContextImports, authRolesImports, configServiceImports, emailModuleImports, paths, pothosImports, prismaImports, typescriptFile, userSessionTypesImports, }) {
+        return {
+            providers: {
+                betterAuthBetterAuthModuleRenderers: {
+                    auth: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.auth,
+                            destination: paths.auth,
+                            importMapProviders: {
+                                authRolesImports,
+                                configServiceImports,
+                                emailModuleImports,
+                                prismaImports,
+                            },
+                            ...options,
+                        }),
+                    },
+                    betterAuthPlugin: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.betterAuthPlugin,
+                            destination: paths.betterAuthPlugin,
+                            importMapProviders: {
+                                appRuntimeImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                    headersUtils: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.headersUtils,
+                            destination: paths.headersUtils,
+                            ...options,
+                        }),
+                    },
+                    userSessionQueries: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.userSessionQueries,
+                            destination: paths.userSessionQueries,
+                            importMapProviders: {
+                                pothosImports,
+                                prismaImports,
+                            },
+                            ...options,
+                        }),
+                    },
+                    userSessionService: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES.userSessionService,
+                            destination: paths.userSessionService,
+                            importMapProviders: {
+                                authContextImports,
+                                userSessionTypesImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                },
+            },
+        };
+    },
+});
+export const BETTER_AUTH_BETTER_AUTH_MODULE_RENDERERS = {
+    provider: betterAuthBetterAuthModuleRenderers,
+    task: betterAuthBetterAuthModuleRenderersTask,
+};
+//# sourceMappingURL=template-renderers.js.map

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

@@ -0,0 +1,48 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+export declare const betterAuthModuleImportsSchema: {
+    Auth: {
+        isTypeOnly: true;
+    };
+    AuthServiceDeps: {
+        isTypeOnly: true;
+    };
+    betterAuthPlugin: {};
+    buildAuth: {};
+    cookiePrefix: {};
+    createBetterAuthUserSessionService: {};
+    toWebHeaders: {};
+};
+export type BetterAuthModuleImportsProvider = TsImportMapProviderFromSchema<typeof betterAuthModuleImportsSchema>;
+export declare const betterAuthModuleImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    Auth: {
+        isTypeOnly: true;
+    };
+    AuthServiceDeps: {
+        isTypeOnly: true;
+    };
+    betterAuthPlugin: {};
+    buildAuth: {};
+    cookiePrefix: {};
+    createBetterAuthUserSessionService: {};
+    toWebHeaders: {};
+}>>;
+export declare const BETTER_AUTH_BETTER_AUTH_MODULE_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>;
+};
+//# sourceMappingURL=ts-import-providers.d.ts.map

package/dist/better-auth/generators/fastify/better-auth-module/generated/ts-import-providers.js

@@ -0,0 +1,40 @@
+import { createTsImportMap, createTsImportMapSchema, packageScope, } from '@baseplate-dev/core-generators';
+import { createGeneratorTask, createReadOnlyProviderType, } from '@baseplate-dev/sync';
+import { BETTER_AUTH_BETTER_AUTH_MODULE_PATHS } from './template-paths.js';
+export const betterAuthModuleImportsSchema = createTsImportMapSchema({
+    Auth: { isTypeOnly: true },
+    AuthServiceDeps: { isTypeOnly: true },
+    betterAuthPlugin: {},
+    buildAuth: {},
+    cookiePrefix: {},
+    createBetterAuthUserSessionService: {},
+    toWebHeaders: {},
+});
+export const betterAuthModuleImportsProvider = createReadOnlyProviderType('better-auth-module-imports');
+const betterAuthBetterAuthModuleImportsTask = createGeneratorTask({
+    dependencies: {
+        paths: BETTER_AUTH_BETTER_AUTH_MODULE_PATHS.provider,
+    },
+    exports: {
+        betterAuthModuleImports: betterAuthModuleImportsProvider.export(packageScope),
+    },
+    run({ paths }) {
+        return {
+            providers: {
+                betterAuthModuleImports: createTsImportMap(betterAuthModuleImportsSchema, {
+                    Auth: paths.auth,
+                    AuthServiceDeps: paths.auth,
+                    betterAuthPlugin: paths.betterAuthPlugin,
+                    buildAuth: paths.auth,
+                    cookiePrefix: paths.auth,
+                    createBetterAuthUserSessionService: paths.userSessionService,
+                    toWebHeaders: paths.headersUtils,
+                }),
+            },
+        };
+    },
+});
+export const BETTER_AUTH_BETTER_AUTH_MODULE_IMPORTS = {
+    task: betterAuthBetterAuthModuleImportsTask,
+};
+//# sourceMappingURL=ts-import-providers.js.map

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

@@ -0,0 +1,110 @@
+export declare const BETTER_AUTH_BETTER_AUTH_MODULE_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=typed-templates.d.ts.map

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

@@ -0,0 +1,83 @@
+import { createTsTemplateFile } from '@baseplate-dev/core-generators';
+import { appRuntimeImportsProvider, authContextImportsProvider, authRolesImportsProvider, configServiceImportsProvider, pothosImportsProvider, prismaImportsProvider, userSessionTypesImportsProvider, } from '@baseplate-dev/fastify-generators';
+import { emailModuleImportsProvider } from '@baseplate-dev/plugin-email';
+import path from 'node:path';
+const auth = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {
+        authRolesImports: authRolesImportsProvider,
+        configServiceImports: configServiceImportsProvider,
+        emailModuleImports: emailModuleImportsProvider,
+        prismaImports: prismaImportsProvider,
+    },
+    name: 'auth',
+    projectExports: {
+        Auth: { isTypeOnly: true },
+        AuthServiceDeps: { isTypeOnly: true },
+        buildAuth: {},
+        cookiePrefix: {},
+    },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/services/auth.ts'),
+    },
+    variables: {
+        TPL_ACCOUNT_VERIFICATION_EMAIL: {},
+        TPL_PASSWORD_RESET_EMAIL: {},
+        TPL_USER_ROLE_MODEL: {},
+    },
+});
+const betterAuthPlugin = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: { appRuntimeImports: appRuntimeImportsProvider },
+    name: 'better-auth-plugin',
+    projectExports: { betterAuthPlugin: {} },
+    referencedGeneratorTemplates: { headersUtils: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/plugins/better-auth.plugin.ts'),
+    },
+    variables: {},
+});
+const headersUtils = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {},
+    name: 'headers-utils',
+    projectExports: { toWebHeaders: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/utils/headers.utils.ts'),
+    },
+    variables: {},
+});
+const userSessionQueries = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {
+        pothosImports: pothosImportsProvider,
+        prismaImports: prismaImportsProvider,
+    },
+    name: 'user-session-queries',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/schema/user-session.queries.ts'),
+    },
+    variables: {},
+});
+const userSessionService = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {
+        authContextImports: authContextImportsProvider,
+        userSessionTypesImports: userSessionTypesImportsProvider,
+    },
+    name: 'user-session-service',
+    projectExports: { createBetterAuthUserSessionService: {} },
+    referencedGeneratorTemplates: { auth: {}, headersUtils: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/services/user-session.service.ts'),
+    },
+    variables: {},
+});
+export const BETTER_AUTH_BETTER_AUTH_MODULE_TEMPLATES = {
+    auth,
+    betterAuthPlugin,
+    headersUtils,
+    userSessionQueries,
+    userSessionService,
+};
+//# sourceMappingURL=typed-templates.js.map

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

@@ -0,0 +1,4 @@
+export * from './better-auth-module.generator.js';
+export type { BetterAuthModuleImportsProvider } from './generated/ts-import-providers.js';
+export { betterAuthModuleImportsProvider } from './generated/ts-import-providers.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from './better-auth-module.generator.js';
+export { betterAuthModuleImportsProvider } from './generated/ts-import-providers.js';
+//# sourceMappingURL=index.js.map

package/dist/better-auth/generators/fastify/better-auth-module/templates/module/plugins/better-auth.plugin.ts

@@ -0,0 +1,34 @@
+// @ts-nocheck
+
+import type { AppServices } from '%appRuntimeImports';
+
+import { toWebHeaders } from '$headersUtils';
+import fp from 'fastify-plugin';
+
+export const betterAuthPlugin = fp<{
+  services: Pick<AppServices, 'betterAuth'>;
+}>(
+  (fastify, { services }, done) => {
+    fastify.all('/auth/*', async (request, reply) => {
+      const url = new URL(request.url, `http://${request.headers.host}`);
+
+      const req = new Request(url.toString(), {
+        method: request.method,
+        headers: toWebHeaders(request.headers),
+        ...(request.body ? { body: JSON.stringify(request.body) } : {}),
+      });
+
+      const response = await services.betterAuth.handler(req);
+
+      reply.status(response.status);
+      for (const [key, value] of response.headers.entries())
+        reply.header(key, value);
+      reply.send(response.body ? await response.text() : null);
+    });
+
+    done();
+  },
+  {
+    name: 'better-auth',
+  },
+);

package/dist/better-auth/generators/fastify/better-auth-module/templates/module/schema/user-session.queries.ts

@@ -0,0 +1,22 @@
+// @ts-nocheck
+
+import { builder } from '%pothosImports';
+import { prisma } from '%prismaImports';
+
+builder.queryField('viewer', (t) =>
+  t.prismaField({
+    type: 'User',
+    nullable: true,
+    description: 'The currently authenticated user',
+    authorize: ['public'],
+    resolve: async (query, root, args, { auth }) => {
+      if (auth.session?.type !== 'user') {
+        return null;
+      }
+      return prisma.user.findUnique({
+        where: { id: auth.session.userId },
+        ...query,
+      });
+    },
+  }),
+);

package/dist/better-auth/generators/fastify/better-auth-module/templates/module/services/auth.ts

@@ -0,0 +1,107 @@
+// @ts-nocheck
+
+import type { AuthRole } from '%authRolesImports';
+import type { EmailService } from '%emailModuleImports';
+
+import { DEFAULT_USER_ROLES } from '%authRolesImports';
+import { getConfig } from '%configServiceImports';
+import { prisma } from '%prismaImports';
+import { betterAuth } from 'better-auth';
+import { prismaAdapter } from 'better-auth/adapters/prisma';
+import { customSession } from 'better-auth/plugins';
+
+// Read at module scope: this module already requires backend env at import
+// via the Prisma client.
+const config = getConfig();
+
+/**
+ * Returns the cookie prefix for Better Auth.
+ * In development, scopes cookies to the server port to avoid collisions
+ * when running multiple apps on localhost.
+ */
+export const cookiePrefix =
+  config.APP_ENVIRONMENT === 'dev'
+    ? `better-auth-${config.SERVER_PORT}`
+    : 'better-auth';
+
+/**
+ * Dependencies `auth` needs at construction time.
+ */
+export interface AuthServiceDeps {
+  email: EmailService;
+}
+
+export type Auth = ReturnType<typeof buildAuth>;
+
+/**
+ * Constructs a fresh {@link Auth} instance from the given deps. Called once
+ * per AppRuntime, inside `createAppRuntime()`, and exposed as
+ * `services.betterAuth` - not memoized here, since a runtime's services are
+ * only ever built once for the runtime's lifetime.
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- return type is self-referential (Auth is derived from it above); betterAuth()'s inferred generic return type can't be spelled out by hand
+export const buildAuth = ({ email }: AuthServiceDeps) =>
+  betterAuth({
+    database: prismaAdapter(prisma, { provider: 'postgresql' }),
+    secret: config.BETTER_AUTH_SECRET,
+    baseURL: config.BETTER_AUTH_URL,
+    basePath: '/auth',
+    emailAndPassword: {
+      enabled: true,
+      async sendResetPassword({ token, user }) {
+        const resetLink = `${config.AUTH_FRONTEND_URL}/auth/reset-password?token=${token}`;
+        await email.send(TPL_PASSWORD_RESET_EMAIL, {
+          to: user.email,
+          data: { resetLink },
+        });
+      },
+      resetPasswordTokenExpiresIn: 3600,
+    },
+    emailVerification: {
+      sendOnSignUp: true,
+      async sendVerificationEmail({ token, user }) {
+        const verifyLink = `${config.AUTH_FRONTEND_URL}/auth/verify-email?token=${token}`;
+        await email.send(TPL_ACCOUNT_VERIFICATION_EMAIL, {
+          to: user.email,
+          data: { verifyLink },
+        });
+      },
+    },
+    session: {
+      cookieCache: { enabled: true, maxAge: 5 * 60 },
+    },
+    advanced: {
+      cookiePrefix,
+      database: {
+        generateId: false,
+      },
+    },
+    trustedOrigins: config.ALLOWED_ORIGINS.split(',')
+      .map((o) => o.trim())
+      .filter(Boolean),
+    user: {
+      modelName: 'User',
+      changeEmail: {
+        enabled: true,
+      },
+    },
+    plugins: [
+      customSession(async ({ user, session }) => {
+        const userRoles = await TPL_USER_ROLE_MODEL.findMany({
+          where: { userId: user.id },
+        });
+
+        const roles = [
+          ...new Set([...DEFAULT_USER_ROLES, ...userRoles.map((r) => r.role)]),
+        ] as AuthRole[];
+
+        return {
+          user,
+          session: {
+            ...session,
+            roles,
+          },
+        };
+      }),
+    ],
+  });

package/dist/better-auth/generators/fastify/better-auth-module/templates/module/services/user-session.service.ts

@@ -0,0 +1,84 @@
+// @ts-nocheck
+
+import type { Auth } from '$auth';
+import type { AuthUserSessionInfo } from '%authContextImports';
+import type { UserSessionService } from '%userSessionTypesImports';
+import type { FastifyRequest } from 'fastify';
+
+import { cookiePrefix } from '$auth';
+import { toWebHeaders } from '$headersUtils';
+
+function toSessionInfo(
+  session: Auth['$Infer']['Session'],
+): AuthUserSessionInfo {
+  return {
+    id: session.session.id,
+    type: 'user',
+    userId: session.user.id,
+    roles: session.session.roles,
+    expiresAt: new Date(session.session.expiresAt),
+  };
+}
+
+/**
+ * Creates a {@link UserSessionService} backed by Better Auth.
+ *
+ * @param auth - The {@link Auth} instance to look up sessions with.
+ * @returns A {@link UserSessionService} implementation.
+ */
+export function createBetterAuthUserSessionService(
+  auth: Auth,
+): UserSessionService {
+  return {
+    /**
+     * Retrieves the user session information from the request.
+     *
+     * Better Auth looks up sessions purely from request headers, so the
+     * optional `res` parameter on {@link UserSessionService} is unused here.
+     *
+     * @param req - The Fastify request object containing the cookies.
+     * @returns A promise that resolves to the authenticated user session information or undefined if no session.
+     */
+    async getSessionInfoFromRequest(
+      req: FastifyRequest,
+    ): Promise<AuthUserSessionInfo | undefined> {
+      const session = await auth.api.getSession({
+        headers: toWebHeaders(req.headers),
+      });
+
+      if (!session) {
+        return undefined;
+      }
+
+      return toSessionInfo(session);
+    },
+
+    /**
+     * Retrieves the user session information from the authentication token
+     *
+     * @param _req The request object (unused for Better Auth cookie-based sessions)
+     * @param token The session token
+     * @returns The session info or undefined if no session is found
+     */
+    async getSessionInfoFromToken(
+      _req: FastifyRequest,
+      token?: string | null,
+    ): Promise<AuthUserSessionInfo | undefined> {
+      if (!token) {
+        return undefined;
+      }
+
+      const session = await auth.api.getSession({
+        headers: new Headers({
+          cookie: `${cookiePrefix}.session_token=${token}`,
+        }),
+      });
+
+      if (!session) {
+        return undefined;
+      }
+
+      return toSessionInfo(session);
+    },
+  };
+}

package/dist/better-auth/generators/fastify/better-auth-module/templates/module/utils/headers.utils.ts

@@ -0,0 +1,21 @@
+// @ts-nocheck
+
+import type { FastifyRequest } from 'fastify';
+
+/**
+ * Converts Fastify request headers to a Web API Headers object.
+ */
+export function toWebHeaders(headers: FastifyRequest['headers']): Headers {
+  const webHeaders = new Headers();
+  for (const [key, value] of Object.entries(headers)) {
+    if (value == null) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        webHeaders.append(key, v);
+      }
+    } else {
+      webHeaders.append(key, value);
+    }
+  }
+  return webHeaders;
+}

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

@@ -0,0 +1,5 @@
+export * from './better-auth-admin-module/index.js';
+export * from './better-auth-email-templates/index.js';
+export * from './better-auth-module/index.js';
+export * from './seed-initial-user/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './better-auth-admin-module/index.js';
+export * from './better-auth-email-templates/index.js';
+export * from './better-auth-module/index.js';
+export * from './seed-initial-user/index.js';
+//# sourceMappingURL=index.js.map